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:07.573] plan(): Setting new future strategy stack:
[01:28:07.575] List of future strategies:
[01:28:07.575] 1. sequential:
[01:28:07.575]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.575]    - tweaked: FALSE
[01:28:07.575]    - call: future::plan("sequential")
[01:28:07.591] plan(): nbrOfWorkers() = 1
> library("listenv")
> oopts <- c(oopts, options(
+   future.globals.resolve = TRUE,
+   future.globals.onMissing = "error"
+ ))
> 
> message("*** Tricky use cases related to globals ...")
*** Tricky use cases related to globals ...
> 
> 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)
+ 
+   message("availableCores(): ", availableCores())
+ 
+   message("- Local variables with the same name as globals ...")
+ 
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("- plan('%s') ...", strategy))
+     plan(strategy)
+ 
+     methods <- c("conservative", "ordered")
+     for (method in methods) {
+       options(future.globals.method = method)
+       message(sprintf("Method for identifying globals: '%s' ...", method))
+ 
+       a <- 3
+ 
+       yTruth <- local({
+         b <- a
+         a <- 2
+         a * b
+       })
+ 
+       y %<-% {
+         b <- a
+         a <- 2
+         a * b
+       }
+ 
+       rm(list = "a")
+ 
+       res <- try(y, silent = TRUE)
+       if (method == "conservative" && strategy %in% c("multisession", "cluster")) {
+         str(list(res = res))
+         stopifnot(inherits(res, "try-error"))
+       } else {
+         message(sprintf("y = %g", y))
+         stopifnot(identical(y, yTruth))
+       }
+ 
+ 
+       ## Same with forced lazy evaluation
+       a <- 3
+ 
+       y %<-% {
+         b <- a
+         a <- 2
+         a * b
+       } %lazy% TRUE
+ 
+       rm(list = "a")
+ 
+       res <- try(y, silent = TRUE)
+       if (method == "conservative") {
+         str(list(res = res))
+         stopifnot(inherits(res, "try-error"))
+       } else {
+         message(sprintf("y = %g", y))
+         stopifnot(identical(y, yTruth))
+       }
+ 
+ 
+       res <- listenv()
+       a <- 1
+       for (ii in 1:3) {
+         res[[ii]] %<-% {
+           b <- a * ii
+           a <- 0
+           b
+         }
+       }
+       rm(list = "a")
+ 
+       res <- try(unlist(res), silent = TRUE)
+       if (method == "conservative" && strategy %in% c("multisession", "cluster")) {
+         str(list(res = res))
+         stopifnot(inherits(res, "try-error"))
+       } else {
+         print(res)
+         stopifnot(all(res == 1:3))
+       }
+ 
+ 
+       ## Same with forced lazy evaluation
+       res <- listenv()
+       a <- 1
+       for (ii in 1:3) {
+         res[[ii]] %<-% {
+           b <- a * ii
+           a <- 0
+           b
+         } %lazy% TRUE
+       }
+       rm(list = "a")
+ 
+       res <- try(unlist(res), silent = TRUE)
+       if (method == "conservative") {
+         str(list(res = res))
+         stopifnot(inherits(res, "try-error"))
+       } else {
+         print(res)
+         stopifnot(all(res == 1:3))
+       }
+ 
+ 
+       ## Assert that `a` is resolved and turned into a constant future
+       ## at the moment when future `b` is created.
+       ## Requires options(future.globals.resolve = TRUE).
+       a <- future(1)
+       b <- future(value(a) + 1)
+       rm(list = "a")
+       message(sprintf("value(b) = %g", value(b)))
+       stopifnot(value(b) == 2)
+ 
+       a <- future(1)
+       b <- future(value(a) + 1, lazy = TRUE)
+       rm(list = "a")
+       message(sprintf("value(b) = %g", value(b)))
+       stopifnot(value(b) == 2)
+ 
+       a <- future(1, lazy = TRUE)
+       b <- future(value(a) + 1)
+       rm(list = "a")
+       message(sprintf("value(b) = %g", value(b)))
+       stopifnot(value(b) == 2)
+ 
+       a <- future(1, lazy = TRUE)
+       b <- future(value(a) + 1, lazy = TRUE)
+       rm(list = "a")
+       message(sprintf("value(b) = %g", value(b)))
+       stopifnot(value(b) == 2)
+ 
+ 
+       ## BUG FIX: In future (<= 1.0.0) a global 'pkg' would be
+       ## overwritten by the name of the last package attached
+       ## by the future.
+       pkg <- "foo"
+       f <- sequential({ pkg })
+       v <- value(f)
+       message(sprintf("value(f) = %s", sQuote(v)))
+       stopifnot(pkg == "foo", v == "foo")
+       
+       message(sprintf("Method for identifying globals: '%s' ... DONE", method))
+     }
+ 
+     ## BUG FIX: In globals (<= 0.10.3) a global 'x' in LHS of an assignment
+     ## would be missed.
+     options(future.globals.method = "ordered")
+ 
+     ## A local
+     x <- 1
+     f <- future({ x <- 0; x <- x + 1; x })
+     v <- value(f)
+     message(sprintf("value(f) = %s", sQuote(v)))
+     stopifnot(v == 1)
+     
+     ## A global
+     x <- 1
+     f <- future({ x <- x + 1; x })
+     v <- value(f)
+     message(sprintf("value(f) = %s", sQuote(v)))
+     stopifnot(v == 2)
+ 
+     ## A global
+     x <- function() TRUE
+     f <- future({ x <- x(); x })
+     v <- value(f)
+     message(sprintf("value(f) = %s", sQuote(v)))
+     stopifnot(v == TRUE)
+   } ## for (strategy ...)
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
availableCores(): 1
- Local variables with the same name as globals ...
- plan('sequential') ...
[01:28:07.714] plan(): Setting new future strategy stack:
[01:28:07.714] List of future strategies:
[01:28:07.714] 1. sequential:
[01:28:07.714]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.714]    - tweaked: FALSE
[01:28:07.714]    - call: plan(strategy)
[01:28:07.728] plan(): nbrOfWorkers() = 1
Method for identifying globals: 'conservative' ...
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.731] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.731] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.739] - globals found: [3] '{', '<-', '*'
[01:28:07.739] Searching for globals ... DONE
[01:28:07.739] Resolving globals: TRUE
[01:28:07.739] Resolving any globals that are futures ...
[01:28:07.740] - globals: [3] '{', '<-', '*'
[01:28:07.740] Resolving any globals that are futures ... DONE
[01:28:07.740] 
[01:28:07.741] 
[01:28:07.741] getGlobalsAndPackages() ... DONE
[01:28:07.742] run() for 'Future' ...
[01:28:07.742] - state: 'created'
[01:28:07.742] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.743] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.743] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.743]   - Field: 'label'
[01:28:07.743]   - Field: 'local'
[01:28:07.744]   - Field: 'owner'
[01:28:07.744]   - Field: 'envir'
[01:28:07.744]   - Field: 'packages'
[01:28:07.744]   - Field: 'gc'
[01:28:07.744]   - Field: 'conditions'
[01:28:07.745]   - Field: 'expr'
[01:28:07.745]   - Field: 'uuid'
[01:28:07.745]   - Field: 'seed'
[01:28:07.745]   - Field: 'version'
[01:28:07.745]   - Field: 'result'
[01:28:07.745]   - Field: 'asynchronous'
[01:28:07.746]   - Field: 'calls'
[01:28:07.746]   - Field: 'globals'
[01:28:07.746]   - Field: 'stdout'
[01:28:07.746]   - Field: 'earlySignal'
[01:28:07.746]   - Field: 'lazy'
[01:28:07.746]   - Field: 'state'
[01:28:07.747] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.747] - Launch lazy future ...
[01:28:07.748] Packages needed by the future expression (n = 0): <none>
[01:28:07.748] Packages needed by future strategies (n = 0): <none>
[01:28:07.749] {
[01:28:07.749]     {
[01:28:07.749]         {
[01:28:07.749]             ...future.startTime <- base::Sys.time()
[01:28:07.749]             {
[01:28:07.749]                 {
[01:28:07.749]                   {
[01:28:07.749]                     base::local({
[01:28:07.749]                       has_future <- base::requireNamespace("future", 
[01:28:07.749]                         quietly = TRUE)
[01:28:07.749]                       if (has_future) {
[01:28:07.749]                         ns <- base::getNamespace("future")
[01:28:07.749]                         version <- ns[[".package"]][["version"]]
[01:28:07.749]                         if (is.null(version)) 
[01:28:07.749]                           version <- utils::packageVersion("future")
[01:28:07.749]                       }
[01:28:07.749]                       else {
[01:28:07.749]                         version <- NULL
[01:28:07.749]                       }
[01:28:07.749]                       if (!has_future || version < "1.8.0") {
[01:28:07.749]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.749]                           "", base::R.version$version.string), 
[01:28:07.749]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.749]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.749]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.749]                             "release", "version")], collapse = " "), 
[01:28:07.749]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.749]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.749]                           info)
[01:28:07.749]                         info <- base::paste(info, collapse = "; ")
[01:28:07.749]                         if (!has_future) {
[01:28:07.749]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.749]                             info)
[01:28:07.749]                         }
[01:28:07.749]                         else {
[01:28:07.749]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.749]                             info, version)
[01:28:07.749]                         }
[01:28:07.749]                         base::stop(msg)
[01:28:07.749]                       }
[01:28:07.749]                     })
[01:28:07.749]                   }
[01:28:07.749]                   options(future.plan = NULL)
[01:28:07.749]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.749]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.749]                 }
[01:28:07.749]                 ...future.workdir <- getwd()
[01:28:07.749]             }
[01:28:07.749]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.749]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.749]         }
[01:28:07.749]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.749]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.749]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.749]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.749]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.749]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.749]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.749]             base::names(...future.oldOptions))
[01:28:07.749]     }
[01:28:07.749]     if (FALSE) {
[01:28:07.749]     }
[01:28:07.749]     else {
[01:28:07.749]         if (TRUE) {
[01:28:07.749]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.749]                 open = "w")
[01:28:07.749]         }
[01:28:07.749]         else {
[01:28:07.749]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.749]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.749]         }
[01:28:07.749]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.749]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.749]             base::sink(type = "output", split = FALSE)
[01:28:07.749]             base::close(...future.stdout)
[01:28:07.749]         }, add = TRUE)
[01:28:07.749]     }
[01:28:07.749]     ...future.frame <- base::sys.nframe()
[01:28:07.749]     ...future.conditions <- base::list()
[01:28:07.749]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.749]     if (FALSE) {
[01:28:07.749]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.749]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.749]     }
[01:28:07.749]     ...future.result <- base::tryCatch({
[01:28:07.749]         base::withCallingHandlers({
[01:28:07.749]             ...future.value <- base::withVisible(base::local({
[01:28:07.749]                 b <- a
[01:28:07.749]                 a <- 2
[01:28:07.749]                 a * b
[01:28:07.749]             }))
[01:28:07.749]             future::FutureResult(value = ...future.value$value, 
[01:28:07.749]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.749]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.749]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.749]                     ...future.globalenv.names))
[01:28:07.749]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.749]         }, condition = base::local({
[01:28:07.749]             c <- base::c
[01:28:07.749]             inherits <- base::inherits
[01:28:07.749]             invokeRestart <- base::invokeRestart
[01:28:07.749]             length <- base::length
[01:28:07.749]             list <- base::list
[01:28:07.749]             seq.int <- base::seq.int
[01:28:07.749]             signalCondition <- base::signalCondition
[01:28:07.749]             sys.calls <- base::sys.calls
[01:28:07.749]             `[[` <- base::`[[`
[01:28:07.749]             `+` <- base::`+`
[01:28:07.749]             `<<-` <- base::`<<-`
[01:28:07.749]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.749]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.749]                   3L)]
[01:28:07.749]             }
[01:28:07.749]             function(cond) {
[01:28:07.749]                 is_error <- inherits(cond, "error")
[01:28:07.749]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.749]                   NULL)
[01:28:07.749]                 if (is_error) {
[01:28:07.749]                   sessionInformation <- function() {
[01:28:07.749]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.749]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.749]                       search = base::search(), system = base::Sys.info())
[01:28:07.749]                   }
[01:28:07.749]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.749]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.749]                     cond$call), session = sessionInformation(), 
[01:28:07.749]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.749]                   signalCondition(cond)
[01:28:07.749]                 }
[01:28:07.749]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.749]                 "immediateCondition"))) {
[01:28:07.749]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.749]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.749]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.749]                   if (TRUE && !signal) {
[01:28:07.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.749]                     {
[01:28:07.749]                       inherits <- base::inherits
[01:28:07.749]                       invokeRestart <- base::invokeRestart
[01:28:07.749]                       is.null <- base::is.null
[01:28:07.749]                       muffled <- FALSE
[01:28:07.749]                       if (inherits(cond, "message")) {
[01:28:07.749]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.749]                         if (muffled) 
[01:28:07.749]                           invokeRestart("muffleMessage")
[01:28:07.749]                       }
[01:28:07.749]                       else if (inherits(cond, "warning")) {
[01:28:07.749]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.749]                         if (muffled) 
[01:28:07.749]                           invokeRestart("muffleWarning")
[01:28:07.749]                       }
[01:28:07.749]                       else if (inherits(cond, "condition")) {
[01:28:07.749]                         if (!is.null(pattern)) {
[01:28:07.749]                           computeRestarts <- base::computeRestarts
[01:28:07.749]                           grepl <- base::grepl
[01:28:07.749]                           restarts <- computeRestarts(cond)
[01:28:07.749]                           for (restart in restarts) {
[01:28:07.749]                             name <- restart$name
[01:28:07.749]                             if (is.null(name)) 
[01:28:07.749]                               next
[01:28:07.749]                             if (!grepl(pattern, name)) 
[01:28:07.749]                               next
[01:28:07.749]                             invokeRestart(restart)
[01:28:07.749]                             muffled <- TRUE
[01:28:07.749]                             break
[01:28:07.749]                           }
[01:28:07.749]                         }
[01:28:07.749]                       }
[01:28:07.749]                       invisible(muffled)
[01:28:07.749]                     }
[01:28:07.749]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.749]                   }
[01:28:07.749]                 }
[01:28:07.749]                 else {
[01:28:07.749]                   if (TRUE) {
[01:28:07.749]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.749]                     {
[01:28:07.749]                       inherits <- base::inherits
[01:28:07.749]                       invokeRestart <- base::invokeRestart
[01:28:07.749]                       is.null <- base::is.null
[01:28:07.749]                       muffled <- FALSE
[01:28:07.749]                       if (inherits(cond, "message")) {
[01:28:07.749]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.749]                         if (muffled) 
[01:28:07.749]                           invokeRestart("muffleMessage")
[01:28:07.749]                       }
[01:28:07.749]                       else if (inherits(cond, "warning")) {
[01:28:07.749]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.749]                         if (muffled) 
[01:28:07.749]                           invokeRestart("muffleWarning")
[01:28:07.749]                       }
[01:28:07.749]                       else if (inherits(cond, "condition")) {
[01:28:07.749]                         if (!is.null(pattern)) {
[01:28:07.749]                           computeRestarts <- base::computeRestarts
[01:28:07.749]                           grepl <- base::grepl
[01:28:07.749]                           restarts <- computeRestarts(cond)
[01:28:07.749]                           for (restart in restarts) {
[01:28:07.749]                             name <- restart$name
[01:28:07.749]                             if (is.null(name)) 
[01:28:07.749]                               next
[01:28:07.749]                             if (!grepl(pattern, name)) 
[01:28:07.749]                               next
[01:28:07.749]                             invokeRestart(restart)
[01:28:07.749]                             muffled <- TRUE
[01:28:07.749]                             break
[01:28:07.749]                           }
[01:28:07.749]                         }
[01:28:07.749]                       }
[01:28:07.749]                       invisible(muffled)
[01:28:07.749]                     }
[01:28:07.749]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.749]                   }
[01:28:07.749]                 }
[01:28:07.749]             }
[01:28:07.749]         }))
[01:28:07.749]     }, error = function(ex) {
[01:28:07.749]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.749]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.749]                 ...future.rng), started = ...future.startTime, 
[01:28:07.749]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.749]             version = "1.8"), class = "FutureResult")
[01:28:07.749]     }, finally = {
[01:28:07.749]         if (!identical(...future.workdir, getwd())) 
[01:28:07.749]             setwd(...future.workdir)
[01:28:07.749]         {
[01:28:07.749]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.749]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.749]             }
[01:28:07.749]             base::options(...future.oldOptions)
[01:28:07.749]             if (.Platform$OS.type == "windows") {
[01:28:07.749]                 old_names <- names(...future.oldEnvVars)
[01:28:07.749]                 envs <- base::Sys.getenv()
[01:28:07.749]                 names <- names(envs)
[01:28:07.749]                 common <- intersect(names, old_names)
[01:28:07.749]                 added <- setdiff(names, old_names)
[01:28:07.749]                 removed <- setdiff(old_names, names)
[01:28:07.749]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.749]                   envs[common]]
[01:28:07.749]                 NAMES <- toupper(changed)
[01:28:07.749]                 args <- list()
[01:28:07.749]                 for (kk in seq_along(NAMES)) {
[01:28:07.749]                   name <- changed[[kk]]
[01:28:07.749]                   NAME <- NAMES[[kk]]
[01:28:07.749]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.749]                     next
[01:28:07.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.749]                 }
[01:28:07.749]                 NAMES <- toupper(added)
[01:28:07.749]                 for (kk in seq_along(NAMES)) {
[01:28:07.749]                   name <- added[[kk]]
[01:28:07.749]                   NAME <- NAMES[[kk]]
[01:28:07.749]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.749]                     next
[01:28:07.749]                   args[[name]] <- ""
[01:28:07.749]                 }
[01:28:07.749]                 NAMES <- toupper(removed)
[01:28:07.749]                 for (kk in seq_along(NAMES)) {
[01:28:07.749]                   name <- removed[[kk]]
[01:28:07.749]                   NAME <- NAMES[[kk]]
[01:28:07.749]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.749]                     next
[01:28:07.749]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.749]                 }
[01:28:07.749]                 if (length(args) > 0) 
[01:28:07.749]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.749]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.749]             }
[01:28:07.749]             else {
[01:28:07.749]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.749]             }
[01:28:07.749]             {
[01:28:07.749]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.749]                   0L) {
[01:28:07.749]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.749]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.749]                   base::options(opts)
[01:28:07.749]                 }
[01:28:07.749]                 {
[01:28:07.749]                   {
[01:28:07.749]                     NULL
[01:28:07.749]                     RNGkind("Mersenne-Twister")
[01:28:07.749]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.749]                       inherits = FALSE)
[01:28:07.749]                   }
[01:28:07.749]                   options(future.plan = NULL)
[01:28:07.749]                   if (is.na(NA_character_)) 
[01:28:07.749]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.749]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.749]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.749]                   {
[01:28:07.749]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.749]                     if (!future$lazy) 
[01:28:07.749]                       future <- run(future)
[01:28:07.749]                     invisible(future)
[01:28:07.749]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.749]                 }
[01:28:07.749]             }
[01:28:07.749]         }
[01:28:07.749]     })
[01:28:07.749]     if (TRUE) {
[01:28:07.749]         base::sink(type = "output", split = FALSE)
[01:28:07.749]         if (TRUE) {
[01:28:07.749]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.749]         }
[01:28:07.749]         else {
[01:28:07.749]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.749]         }
[01:28:07.749]         base::close(...future.stdout)
[01:28:07.749]         ...future.stdout <- NULL
[01:28:07.749]     }
[01:28:07.749]     ...future.result$conditions <- ...future.conditions
[01:28:07.749]     ...future.result$finished <- base::Sys.time()
[01:28:07.749]     ...future.result
[01:28:07.749] }
[01:28:07.753] plan(): Setting new future strategy stack:
[01:28:07.754] List of future strategies:
[01:28:07.754] 1. sequential:
[01:28:07.754]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.754]    - tweaked: FALSE
[01:28:07.754]    - call: NULL
[01:28:07.754] plan(): nbrOfWorkers() = 1
[01:28:07.756] plan(): Setting new future strategy stack:
[01:28:07.757] List of future strategies:
[01:28:07.757] 1. sequential:
[01:28:07.757]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.757]    - tweaked: FALSE
[01:28:07.757]    - call: plan(strategy)
[01:28:07.757] plan(): nbrOfWorkers() = 1
[01:28:07.757] SequentialFuture started (and completed)
[01:28:07.758] - Launch lazy future ... done
[01:28:07.758] run() for 'SequentialFuture' ... done
y = 6
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.759] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.760] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.761] - globals found: [3] '{', '<-', '*'
[01:28:07.762] Searching for globals ... DONE
[01:28:07.762] Resolving globals: TRUE
[01:28:07.764] Resolving any globals that are futures ...
[01:28:07.764] - globals: [3] '{', '<-', '*'
[01:28:07.765] Resolving any globals that are futures ... DONE
[01:28:07.765] 
[01:28:07.765] 
[01:28:07.765] getGlobalsAndPackages() ... DONE
[01:28:07.766] run() for 'Future' ...
[01:28:07.766] - state: 'created'
[01:28:07.766] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.767] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.767] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.767]   - Field: 'label'
[01:28:07.767]   - Field: 'local'
[01:28:07.767]   - Field: 'owner'
[01:28:07.768]   - Field: 'envir'
[01:28:07.768]   - Field: 'packages'
[01:28:07.768]   - Field: 'gc'
[01:28:07.768]   - Field: 'conditions'
[01:28:07.768]   - Field: 'expr'
[01:28:07.768]   - Field: 'uuid'
[01:28:07.769]   - Field: 'seed'
[01:28:07.769]   - Field: 'version'
[01:28:07.769]   - Field: 'result'
[01:28:07.769]   - Field: 'asynchronous'
[01:28:07.769]   - Field: 'calls'
[01:28:07.769]   - Field: 'globals'
[01:28:07.770]   - Field: 'stdout'
[01:28:07.770]   - Field: 'earlySignal'
[01:28:07.770]   - Field: 'lazy'
[01:28:07.770]   - Field: 'state'
[01:28:07.770] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.771] - Launch lazy future ...
[01:28:07.771] Packages needed by the future expression (n = 0): <none>
[01:28:07.771] Packages needed by future strategies (n = 0): <none>
[01:28:07.771] {
[01:28:07.771]     {
[01:28:07.771]         {
[01:28:07.771]             ...future.startTime <- base::Sys.time()
[01:28:07.771]             {
[01:28:07.771]                 {
[01:28:07.771]                   {
[01:28:07.771]                     base::local({
[01:28:07.771]                       has_future <- base::requireNamespace("future", 
[01:28:07.771]                         quietly = TRUE)
[01:28:07.771]                       if (has_future) {
[01:28:07.771]                         ns <- base::getNamespace("future")
[01:28:07.771]                         version <- ns[[".package"]][["version"]]
[01:28:07.771]                         if (is.null(version)) 
[01:28:07.771]                           version <- utils::packageVersion("future")
[01:28:07.771]                       }
[01:28:07.771]                       else {
[01:28:07.771]                         version <- NULL
[01:28:07.771]                       }
[01:28:07.771]                       if (!has_future || version < "1.8.0") {
[01:28:07.771]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.771]                           "", base::R.version$version.string), 
[01:28:07.771]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.771]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.771]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.771]                             "release", "version")], collapse = " "), 
[01:28:07.771]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.771]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.771]                           info)
[01:28:07.771]                         info <- base::paste(info, collapse = "; ")
[01:28:07.771]                         if (!has_future) {
[01:28:07.771]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.771]                             info)
[01:28:07.771]                         }
[01:28:07.771]                         else {
[01:28:07.771]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.771]                             info, version)
[01:28:07.771]                         }
[01:28:07.771]                         base::stop(msg)
[01:28:07.771]                       }
[01:28:07.771]                     })
[01:28:07.771]                   }
[01:28:07.771]                   options(future.plan = NULL)
[01:28:07.771]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.771]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.771]                 }
[01:28:07.771]                 ...future.workdir <- getwd()
[01:28:07.771]             }
[01:28:07.771]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.771]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.771]         }
[01:28:07.771]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.771]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.771]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.771]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.771]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.771]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.771]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.771]             base::names(...future.oldOptions))
[01:28:07.771]     }
[01:28:07.771]     if (FALSE) {
[01:28:07.771]     }
[01:28:07.771]     else {
[01:28:07.771]         if (TRUE) {
[01:28:07.771]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.771]                 open = "w")
[01:28:07.771]         }
[01:28:07.771]         else {
[01:28:07.771]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.771]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.771]         }
[01:28:07.771]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.771]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.771]             base::sink(type = "output", split = FALSE)
[01:28:07.771]             base::close(...future.stdout)
[01:28:07.771]         }, add = TRUE)
[01:28:07.771]     }
[01:28:07.771]     ...future.frame <- base::sys.nframe()
[01:28:07.771]     ...future.conditions <- base::list()
[01:28:07.771]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.771]     if (FALSE) {
[01:28:07.771]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.771]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.771]     }
[01:28:07.771]     ...future.result <- base::tryCatch({
[01:28:07.771]         base::withCallingHandlers({
[01:28:07.771]             ...future.value <- base::withVisible(base::local({
[01:28:07.771]                 b <- a
[01:28:07.771]                 a <- 2
[01:28:07.771]                 a * b
[01:28:07.771]             }))
[01:28:07.771]             future::FutureResult(value = ...future.value$value, 
[01:28:07.771]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.771]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.771]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.771]                     ...future.globalenv.names))
[01:28:07.771]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.771]         }, condition = base::local({
[01:28:07.771]             c <- base::c
[01:28:07.771]             inherits <- base::inherits
[01:28:07.771]             invokeRestart <- base::invokeRestart
[01:28:07.771]             length <- base::length
[01:28:07.771]             list <- base::list
[01:28:07.771]             seq.int <- base::seq.int
[01:28:07.771]             signalCondition <- base::signalCondition
[01:28:07.771]             sys.calls <- base::sys.calls
[01:28:07.771]             `[[` <- base::`[[`
[01:28:07.771]             `+` <- base::`+`
[01:28:07.771]             `<<-` <- base::`<<-`
[01:28:07.771]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.771]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.771]                   3L)]
[01:28:07.771]             }
[01:28:07.771]             function(cond) {
[01:28:07.771]                 is_error <- inherits(cond, "error")
[01:28:07.771]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.771]                   NULL)
[01:28:07.771]                 if (is_error) {
[01:28:07.771]                   sessionInformation <- function() {
[01:28:07.771]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.771]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.771]                       search = base::search(), system = base::Sys.info())
[01:28:07.771]                   }
[01:28:07.771]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.771]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.771]                     cond$call), session = sessionInformation(), 
[01:28:07.771]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.771]                   signalCondition(cond)
[01:28:07.771]                 }
[01:28:07.771]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.771]                 "immediateCondition"))) {
[01:28:07.771]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.771]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.771]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.771]                   if (TRUE && !signal) {
[01:28:07.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.771]                     {
[01:28:07.771]                       inherits <- base::inherits
[01:28:07.771]                       invokeRestart <- base::invokeRestart
[01:28:07.771]                       is.null <- base::is.null
[01:28:07.771]                       muffled <- FALSE
[01:28:07.771]                       if (inherits(cond, "message")) {
[01:28:07.771]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.771]                         if (muffled) 
[01:28:07.771]                           invokeRestart("muffleMessage")
[01:28:07.771]                       }
[01:28:07.771]                       else if (inherits(cond, "warning")) {
[01:28:07.771]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.771]                         if (muffled) 
[01:28:07.771]                           invokeRestart("muffleWarning")
[01:28:07.771]                       }
[01:28:07.771]                       else if (inherits(cond, "condition")) {
[01:28:07.771]                         if (!is.null(pattern)) {
[01:28:07.771]                           computeRestarts <- base::computeRestarts
[01:28:07.771]                           grepl <- base::grepl
[01:28:07.771]                           restarts <- computeRestarts(cond)
[01:28:07.771]                           for (restart in restarts) {
[01:28:07.771]                             name <- restart$name
[01:28:07.771]                             if (is.null(name)) 
[01:28:07.771]                               next
[01:28:07.771]                             if (!grepl(pattern, name)) 
[01:28:07.771]                               next
[01:28:07.771]                             invokeRestart(restart)
[01:28:07.771]                             muffled <- TRUE
[01:28:07.771]                             break
[01:28:07.771]                           }
[01:28:07.771]                         }
[01:28:07.771]                       }
[01:28:07.771]                       invisible(muffled)
[01:28:07.771]                     }
[01:28:07.771]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.771]                   }
[01:28:07.771]                 }
[01:28:07.771]                 else {
[01:28:07.771]                   if (TRUE) {
[01:28:07.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.771]                     {
[01:28:07.771]                       inherits <- base::inherits
[01:28:07.771]                       invokeRestart <- base::invokeRestart
[01:28:07.771]                       is.null <- base::is.null
[01:28:07.771]                       muffled <- FALSE
[01:28:07.771]                       if (inherits(cond, "message")) {
[01:28:07.771]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.771]                         if (muffled) 
[01:28:07.771]                           invokeRestart("muffleMessage")
[01:28:07.771]                       }
[01:28:07.771]                       else if (inherits(cond, "warning")) {
[01:28:07.771]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.771]                         if (muffled) 
[01:28:07.771]                           invokeRestart("muffleWarning")
[01:28:07.771]                       }
[01:28:07.771]                       else if (inherits(cond, "condition")) {
[01:28:07.771]                         if (!is.null(pattern)) {
[01:28:07.771]                           computeRestarts <- base::computeRestarts
[01:28:07.771]                           grepl <- base::grepl
[01:28:07.771]                           restarts <- computeRestarts(cond)
[01:28:07.771]                           for (restart in restarts) {
[01:28:07.771]                             name <- restart$name
[01:28:07.771]                             if (is.null(name)) 
[01:28:07.771]                               next
[01:28:07.771]                             if (!grepl(pattern, name)) 
[01:28:07.771]                               next
[01:28:07.771]                             invokeRestart(restart)
[01:28:07.771]                             muffled <- TRUE
[01:28:07.771]                             break
[01:28:07.771]                           }
[01:28:07.771]                         }
[01:28:07.771]                       }
[01:28:07.771]                       invisible(muffled)
[01:28:07.771]                     }
[01:28:07.771]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.771]                   }
[01:28:07.771]                 }
[01:28:07.771]             }
[01:28:07.771]         }))
[01:28:07.771]     }, error = function(ex) {
[01:28:07.771]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.771]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.771]                 ...future.rng), started = ...future.startTime, 
[01:28:07.771]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.771]             version = "1.8"), class = "FutureResult")
[01:28:07.771]     }, finally = {
[01:28:07.771]         if (!identical(...future.workdir, getwd())) 
[01:28:07.771]             setwd(...future.workdir)
[01:28:07.771]         {
[01:28:07.771]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.771]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.771]             }
[01:28:07.771]             base::options(...future.oldOptions)
[01:28:07.771]             if (.Platform$OS.type == "windows") {
[01:28:07.771]                 old_names <- names(...future.oldEnvVars)
[01:28:07.771]                 envs <- base::Sys.getenv()
[01:28:07.771]                 names <- names(envs)
[01:28:07.771]                 common <- intersect(names, old_names)
[01:28:07.771]                 added <- setdiff(names, old_names)
[01:28:07.771]                 removed <- setdiff(old_names, names)
[01:28:07.771]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.771]                   envs[common]]
[01:28:07.771]                 NAMES <- toupper(changed)
[01:28:07.771]                 args <- list()
[01:28:07.771]                 for (kk in seq_along(NAMES)) {
[01:28:07.771]                   name <- changed[[kk]]
[01:28:07.771]                   NAME <- NAMES[[kk]]
[01:28:07.771]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.771]                     next
[01:28:07.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.771]                 }
[01:28:07.771]                 NAMES <- toupper(added)
[01:28:07.771]                 for (kk in seq_along(NAMES)) {
[01:28:07.771]                   name <- added[[kk]]
[01:28:07.771]                   NAME <- NAMES[[kk]]
[01:28:07.771]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.771]                     next
[01:28:07.771]                   args[[name]] <- ""
[01:28:07.771]                 }
[01:28:07.771]                 NAMES <- toupper(removed)
[01:28:07.771]                 for (kk in seq_along(NAMES)) {
[01:28:07.771]                   name <- removed[[kk]]
[01:28:07.771]                   NAME <- NAMES[[kk]]
[01:28:07.771]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.771]                     next
[01:28:07.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.771]                 }
[01:28:07.771]                 if (length(args) > 0) 
[01:28:07.771]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.771]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.771]             }
[01:28:07.771]             else {
[01:28:07.771]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.771]             }
[01:28:07.771]             {
[01:28:07.771]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.771]                   0L) {
[01:28:07.771]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.771]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.771]                   base::options(opts)
[01:28:07.771]                 }
[01:28:07.771]                 {
[01:28:07.771]                   {
[01:28:07.771]                     NULL
[01:28:07.771]                     RNGkind("Mersenne-Twister")
[01:28:07.771]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.771]                       inherits = FALSE)
[01:28:07.771]                   }
[01:28:07.771]                   options(future.plan = NULL)
[01:28:07.771]                   if (is.na(NA_character_)) 
[01:28:07.771]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.771]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.771]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.771]                   {
[01:28:07.771]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.771]                     if (!future$lazy) 
[01:28:07.771]                       future <- run(future)
[01:28:07.771]                     invisible(future)
[01:28:07.771]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.771]                 }
[01:28:07.771]             }
[01:28:07.771]         }
[01:28:07.771]     })
[01:28:07.771]     if (TRUE) {
[01:28:07.771]         base::sink(type = "output", split = FALSE)
[01:28:07.771]         if (TRUE) {
[01:28:07.771]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.771]         }
[01:28:07.771]         else {
[01:28:07.771]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.771]         }
[01:28:07.771]         base::close(...future.stdout)
[01:28:07.771]         ...future.stdout <- NULL
[01:28:07.771]     }
[01:28:07.771]     ...future.result$conditions <- ...future.conditions
[01:28:07.771]     ...future.result$finished <- base::Sys.time()
[01:28:07.771]     ...future.result
[01:28:07.771] }
[01:28:07.776] plan(): Setting new future strategy stack:
[01:28:07.776] List of future strategies:
[01:28:07.776] 1. sequential:
[01:28:07.776]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.776]    - tweaked: FALSE
[01:28:07.776]    - call: NULL
[01:28:07.776] plan(): nbrOfWorkers() = 1
[01:28:07.778] plan(): Setting new future strategy stack:
[01:28:07.778] List of future strategies:
[01:28:07.778] 1. sequential:
[01:28:07.778]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.778]    - tweaked: FALSE
[01:28:07.778]    - call: plan(strategy)
[01:28:07.779] plan(): nbrOfWorkers() = 1
[01:28:07.779] SequentialFuture started (and completed)
[01:28:07.779] signalConditions() ...
[01:28:07.779]  - include = 'immediateCondition'
[01:28:07.779]  - exclude = 
[01:28:07.780]  - resignal = FALSE
[01:28:07.780]  - Number of conditions: 1
[01:28:07.780] signalConditions() ... done
[01:28:07.780] - Launch lazy future ... done
[01:28:07.780] run() for 'SequentialFuture' ... done
[01:28:07.781] signalConditions() ...
[01:28:07.781]  - include = 'immediateCondition'
[01:28:07.781]  - exclude = 
[01:28:07.781]  - resignal = FALSE
[01:28:07.781]  - Number of conditions: 1
[01:28:07.781] signalConditions() ... done
[01:28:07.782] Future state: 'finished'
[01:28:07.782] signalConditions() ...
[01:28:07.782]  - include = 'condition'
[01:28:07.782]  - exclude = 'immediateCondition'
[01:28:07.782]  - resignal = TRUE
[01:28:07.782]  - Number of conditions: 1
[01:28:07.783]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:07.783] signalConditions() ... done
List of 1
 $ res: 'try-error' chr "Error in eval(quote({ : object 'a' not found\n"
  ..- attr(*, "condition")=List of 3
  .. ..$ message    : chr "object 'a' not found"
  .. ..$ call       : language eval(quote({     b <- a ...
  .. ..$ future.info:List of 5
  .. .. ..$ condition:List of 2
  .. .. .. ..$ message: chr "object 'a' not found"
  .. .. .. ..$ call   : language eval(quote({     b <- a ...
  .. .. .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  .. .. ..$ calls    :List of 11
  .. .. .. ..$ : language y %<-% {     b <- a ...
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language y %<-% {     b <- a ...
  .. .. .. ..$ : language futureAssignInternal(target, expr, envir = envir, substitute = FALSE)
  .. .. .. ..$ : language futureAssign(name, expr, envir = envir, assign.env = assign.env, substitute = FALSE)
  .. .. .. ..$ : language do.call(future::future, args = future.args, envir = assign.env)
  .. .. .. ..$ : language (function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE,      seed = FALSE, globals = TRUE, pack| __truncated__ ...
  .. .. .. ..$ : language Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, seed = seed,      globals = globals, packages = pack| __truncated__ ...
  .. .. .. ..$ : language eval(quote({     b <- a ...
  .. .. .. ..$ : language eval(quote({     b <- a ...
  .. .. ..$ session  :List of 6
  .. .. .. ..$ r         :List of 15
  .. .. .. .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. .. .. .. ..$ arch          : chr "x86_64"
  .. .. .. .. ..$ os            : chr "mingw32"
  .. .. .. .. ..$ crt           : chr "ucrt"
  .. .. .. .. ..$ system        : chr "x86_64, mingw32"
  .. .. .. .. ..$ status        : chr "Under development (unstable)"
  .. .. .. .. ..$ major         : chr "4"
  .. .. .. .. ..$ minor         : chr "4.0"
  .. .. .. .. ..$ year          : chr "2023"
  .. .. .. .. ..$ month         : chr "12"
  .. .. .. .. ..$ day           : chr "20"
  .. .. .. .. ..$ svn rev       : chr "85713"
  .. .. .. .. ..$ language      : chr "R"
  .. .. .. .. ..$ version.string: chr "R Under development (unstable) (2023-12-20 r85713 ucrt)"
  .. .. .. .. ..$ nickname      : chr "Unsuffered Consequences"
  .. .. .. ..$ locale    : chr "LC_COLLATE=C;LC_CTYPE=German_Germany.utf8;LC_MONETARY=C;LC_NUMERIC=C;LC_TIME=C"
  .. .. .. ..$ rngkind   : chr [1:3] "Mersenne-Twister" "Inversion" "Rejection"
  .. .. .. ..$ namespaces: chr [1:16] "compiler" "parallelly" "graphics" "tools" ...
  .. .. .. ..$ search    : chr [1:11] ".GlobalEnv" "package:listenv" "package:future" "package:stats" ...
  .. .. .. ..$ system    : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. .. ..$ timestamp: POSIXct[1:1], format: "2023-12-22 01:28:07"
  .. .. ..$ signaled : int 1
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.806] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.806] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.808] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:07.808] Searching for globals ... DONE
[01:28:07.808] Resolving globals: TRUE
[01:28:07.808] Resolving any globals that are futures ...
[01:28:07.809] - globals: [4] '{', '<-', '*', 'ii'
[01:28:07.809] Resolving any globals that are futures ... DONE
[01:28:07.809] Resolving futures part of globals (recursively) ...
[01:28:07.810] resolve() on list ...
[01:28:07.810]  recursive: 99
[01:28:07.811]  length: 1
[01:28:07.811]  elements: 'ii'
[01:28:07.811]  length: 0 (resolved future 1)
[01:28:07.811] resolve() on list ... DONE
[01:28:07.812] - globals: [1] 'ii'
[01:28:07.812] Resolving futures part of globals (recursively) ... DONE
[01:28:07.812] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:07.813] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:07.813] - globals: [1] 'ii'
[01:28:07.813] 
[01:28:07.813] getGlobalsAndPackages() ... DONE
[01:28:07.814] run() for 'Future' ...
[01:28:07.814] - state: 'created'
[01:28:07.814] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.815] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.815] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.815]   - Field: 'label'
[01:28:07.815]   - Field: 'local'
[01:28:07.815]   - Field: 'owner'
[01:28:07.816]   - Field: 'envir'
[01:28:07.816]   - Field: 'packages'
[01:28:07.816]   - Field: 'gc'
[01:28:07.816]   - Field: 'conditions'
[01:28:07.816]   - Field: 'expr'
[01:28:07.816]   - Field: 'uuid'
[01:28:07.817]   - Field: 'seed'
[01:28:07.817]   - Field: 'version'
[01:28:07.817]   - Field: 'result'
[01:28:07.817]   - Field: 'asynchronous'
[01:28:07.817]   - Field: 'calls'
[01:28:07.817]   - Field: 'globals'
[01:28:07.818]   - Field: 'stdout'
[01:28:07.818]   - Field: 'earlySignal'
[01:28:07.818]   - Field: 'lazy'
[01:28:07.818]   - Field: 'state'
[01:28:07.818] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.819] - Launch lazy future ...
[01:28:07.819] Packages needed by the future expression (n = 0): <none>
[01:28:07.819] Packages needed by future strategies (n = 0): <none>
[01:28:07.820] {
[01:28:07.820]     {
[01:28:07.820]         {
[01:28:07.820]             ...future.startTime <- base::Sys.time()
[01:28:07.820]             {
[01:28:07.820]                 {
[01:28:07.820]                   {
[01:28:07.820]                     base::local({
[01:28:07.820]                       has_future <- base::requireNamespace("future", 
[01:28:07.820]                         quietly = TRUE)
[01:28:07.820]                       if (has_future) {
[01:28:07.820]                         ns <- base::getNamespace("future")
[01:28:07.820]                         version <- ns[[".package"]][["version"]]
[01:28:07.820]                         if (is.null(version)) 
[01:28:07.820]                           version <- utils::packageVersion("future")
[01:28:07.820]                       }
[01:28:07.820]                       else {
[01:28:07.820]                         version <- NULL
[01:28:07.820]                       }
[01:28:07.820]                       if (!has_future || version < "1.8.0") {
[01:28:07.820]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.820]                           "", base::R.version$version.string), 
[01:28:07.820]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.820]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.820]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.820]                             "release", "version")], collapse = " "), 
[01:28:07.820]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.820]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.820]                           info)
[01:28:07.820]                         info <- base::paste(info, collapse = "; ")
[01:28:07.820]                         if (!has_future) {
[01:28:07.820]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.820]                             info)
[01:28:07.820]                         }
[01:28:07.820]                         else {
[01:28:07.820]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.820]                             info, version)
[01:28:07.820]                         }
[01:28:07.820]                         base::stop(msg)
[01:28:07.820]                       }
[01:28:07.820]                     })
[01:28:07.820]                   }
[01:28:07.820]                   options(future.plan = NULL)
[01:28:07.820]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.820]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.820]                 }
[01:28:07.820]                 ...future.workdir <- getwd()
[01:28:07.820]             }
[01:28:07.820]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.820]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.820]         }
[01:28:07.820]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.820]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.820]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.820]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.820]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.820]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.820]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.820]             base::names(...future.oldOptions))
[01:28:07.820]     }
[01:28:07.820]     if (FALSE) {
[01:28:07.820]     }
[01:28:07.820]     else {
[01:28:07.820]         if (TRUE) {
[01:28:07.820]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.820]                 open = "w")
[01:28:07.820]         }
[01:28:07.820]         else {
[01:28:07.820]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.820]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.820]         }
[01:28:07.820]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.820]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.820]             base::sink(type = "output", split = FALSE)
[01:28:07.820]             base::close(...future.stdout)
[01:28:07.820]         }, add = TRUE)
[01:28:07.820]     }
[01:28:07.820]     ...future.frame <- base::sys.nframe()
[01:28:07.820]     ...future.conditions <- base::list()
[01:28:07.820]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.820]     if (FALSE) {
[01:28:07.820]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.820]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.820]     }
[01:28:07.820]     ...future.result <- base::tryCatch({
[01:28:07.820]         base::withCallingHandlers({
[01:28:07.820]             ...future.value <- base::withVisible(base::local({
[01:28:07.820]                 b <- a * ii
[01:28:07.820]                 a <- 0
[01:28:07.820]                 b
[01:28:07.820]             }))
[01:28:07.820]             future::FutureResult(value = ...future.value$value, 
[01:28:07.820]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.820]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.820]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.820]                     ...future.globalenv.names))
[01:28:07.820]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.820]         }, condition = base::local({
[01:28:07.820]             c <- base::c
[01:28:07.820]             inherits <- base::inherits
[01:28:07.820]             invokeRestart <- base::invokeRestart
[01:28:07.820]             length <- base::length
[01:28:07.820]             list <- base::list
[01:28:07.820]             seq.int <- base::seq.int
[01:28:07.820]             signalCondition <- base::signalCondition
[01:28:07.820]             sys.calls <- base::sys.calls
[01:28:07.820]             `[[` <- base::`[[`
[01:28:07.820]             `+` <- base::`+`
[01:28:07.820]             `<<-` <- base::`<<-`
[01:28:07.820]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.820]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.820]                   3L)]
[01:28:07.820]             }
[01:28:07.820]             function(cond) {
[01:28:07.820]                 is_error <- inherits(cond, "error")
[01:28:07.820]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.820]                   NULL)
[01:28:07.820]                 if (is_error) {
[01:28:07.820]                   sessionInformation <- function() {
[01:28:07.820]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.820]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.820]                       search = base::search(), system = base::Sys.info())
[01:28:07.820]                   }
[01:28:07.820]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.820]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.820]                     cond$call), session = sessionInformation(), 
[01:28:07.820]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.820]                   signalCondition(cond)
[01:28:07.820]                 }
[01:28:07.820]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.820]                 "immediateCondition"))) {
[01:28:07.820]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.820]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.820]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.820]                   if (TRUE && !signal) {
[01:28:07.820]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.820]                     {
[01:28:07.820]                       inherits <- base::inherits
[01:28:07.820]                       invokeRestart <- base::invokeRestart
[01:28:07.820]                       is.null <- base::is.null
[01:28:07.820]                       muffled <- FALSE
[01:28:07.820]                       if (inherits(cond, "message")) {
[01:28:07.820]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.820]                         if (muffled) 
[01:28:07.820]                           invokeRestart("muffleMessage")
[01:28:07.820]                       }
[01:28:07.820]                       else if (inherits(cond, "warning")) {
[01:28:07.820]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.820]                         if (muffled) 
[01:28:07.820]                           invokeRestart("muffleWarning")
[01:28:07.820]                       }
[01:28:07.820]                       else if (inherits(cond, "condition")) {
[01:28:07.820]                         if (!is.null(pattern)) {
[01:28:07.820]                           computeRestarts <- base::computeRestarts
[01:28:07.820]                           grepl <- base::grepl
[01:28:07.820]                           restarts <- computeRestarts(cond)
[01:28:07.820]                           for (restart in restarts) {
[01:28:07.820]                             name <- restart$name
[01:28:07.820]                             if (is.null(name)) 
[01:28:07.820]                               next
[01:28:07.820]                             if (!grepl(pattern, name)) 
[01:28:07.820]                               next
[01:28:07.820]                             invokeRestart(restart)
[01:28:07.820]                             muffled <- TRUE
[01:28:07.820]                             break
[01:28:07.820]                           }
[01:28:07.820]                         }
[01:28:07.820]                       }
[01:28:07.820]                       invisible(muffled)
[01:28:07.820]                     }
[01:28:07.820]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.820]                   }
[01:28:07.820]                 }
[01:28:07.820]                 else {
[01:28:07.820]                   if (TRUE) {
[01:28:07.820]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.820]                     {
[01:28:07.820]                       inherits <- base::inherits
[01:28:07.820]                       invokeRestart <- base::invokeRestart
[01:28:07.820]                       is.null <- base::is.null
[01:28:07.820]                       muffled <- FALSE
[01:28:07.820]                       if (inherits(cond, "message")) {
[01:28:07.820]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.820]                         if (muffled) 
[01:28:07.820]                           invokeRestart("muffleMessage")
[01:28:07.820]                       }
[01:28:07.820]                       else if (inherits(cond, "warning")) {
[01:28:07.820]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.820]                         if (muffled) 
[01:28:07.820]                           invokeRestart("muffleWarning")
[01:28:07.820]                       }
[01:28:07.820]                       else if (inherits(cond, "condition")) {
[01:28:07.820]                         if (!is.null(pattern)) {
[01:28:07.820]                           computeRestarts <- base::computeRestarts
[01:28:07.820]                           grepl <- base::grepl
[01:28:07.820]                           restarts <- computeRestarts(cond)
[01:28:07.820]                           for (restart in restarts) {
[01:28:07.820]                             name <- restart$name
[01:28:07.820]                             if (is.null(name)) 
[01:28:07.820]                               next
[01:28:07.820]                             if (!grepl(pattern, name)) 
[01:28:07.820]                               next
[01:28:07.820]                             invokeRestart(restart)
[01:28:07.820]                             muffled <- TRUE
[01:28:07.820]                             break
[01:28:07.820]                           }
[01:28:07.820]                         }
[01:28:07.820]                       }
[01:28:07.820]                       invisible(muffled)
[01:28:07.820]                     }
[01:28:07.820]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.820]                   }
[01:28:07.820]                 }
[01:28:07.820]             }
[01:28:07.820]         }))
[01:28:07.820]     }, error = function(ex) {
[01:28:07.820]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.820]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.820]                 ...future.rng), started = ...future.startTime, 
[01:28:07.820]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.820]             version = "1.8"), class = "FutureResult")
[01:28:07.820]     }, finally = {
[01:28:07.820]         if (!identical(...future.workdir, getwd())) 
[01:28:07.820]             setwd(...future.workdir)
[01:28:07.820]         {
[01:28:07.820]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.820]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.820]             }
[01:28:07.820]             base::options(...future.oldOptions)
[01:28:07.820]             if (.Platform$OS.type == "windows") {
[01:28:07.820]                 old_names <- names(...future.oldEnvVars)
[01:28:07.820]                 envs <- base::Sys.getenv()
[01:28:07.820]                 names <- names(envs)
[01:28:07.820]                 common <- intersect(names, old_names)
[01:28:07.820]                 added <- setdiff(names, old_names)
[01:28:07.820]                 removed <- setdiff(old_names, names)
[01:28:07.820]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.820]                   envs[common]]
[01:28:07.820]                 NAMES <- toupper(changed)
[01:28:07.820]                 args <- list()
[01:28:07.820]                 for (kk in seq_along(NAMES)) {
[01:28:07.820]                   name <- changed[[kk]]
[01:28:07.820]                   NAME <- NAMES[[kk]]
[01:28:07.820]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.820]                     next
[01:28:07.820]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.820]                 }
[01:28:07.820]                 NAMES <- toupper(added)
[01:28:07.820]                 for (kk in seq_along(NAMES)) {
[01:28:07.820]                   name <- added[[kk]]
[01:28:07.820]                   NAME <- NAMES[[kk]]
[01:28:07.820]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.820]                     next
[01:28:07.820]                   args[[name]] <- ""
[01:28:07.820]                 }
[01:28:07.820]                 NAMES <- toupper(removed)
[01:28:07.820]                 for (kk in seq_along(NAMES)) {
[01:28:07.820]                   name <- removed[[kk]]
[01:28:07.820]                   NAME <- NAMES[[kk]]
[01:28:07.820]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.820]                     next
[01:28:07.820]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.820]                 }
[01:28:07.820]                 if (length(args) > 0) 
[01:28:07.820]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.820]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.820]             }
[01:28:07.820]             else {
[01:28:07.820]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.820]             }
[01:28:07.820]             {
[01:28:07.820]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.820]                   0L) {
[01:28:07.820]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.820]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.820]                   base::options(opts)
[01:28:07.820]                 }
[01:28:07.820]                 {
[01:28:07.820]                   {
[01:28:07.820]                     NULL
[01:28:07.820]                     RNGkind("Mersenne-Twister")
[01:28:07.820]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.820]                       inherits = FALSE)
[01:28:07.820]                   }
[01:28:07.820]                   options(future.plan = NULL)
[01:28:07.820]                   if (is.na(NA_character_)) 
[01:28:07.820]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.820]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.820]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.820]                   {
[01:28:07.820]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.820]                     if (!future$lazy) 
[01:28:07.820]                       future <- run(future)
[01:28:07.820]                     invisible(future)
[01:28:07.820]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.820]                 }
[01:28:07.820]             }
[01:28:07.820]         }
[01:28:07.820]     })
[01:28:07.820]     if (TRUE) {
[01:28:07.820]         base::sink(type = "output", split = FALSE)
[01:28:07.820]         if (TRUE) {
[01:28:07.820]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.820]         }
[01:28:07.820]         else {
[01:28:07.820]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.820]         }
[01:28:07.820]         base::close(...future.stdout)
[01:28:07.820]         ...future.stdout <- NULL
[01:28:07.820]     }
[01:28:07.820]     ...future.result$conditions <- ...future.conditions
[01:28:07.820]     ...future.result$finished <- base::Sys.time()
[01:28:07.820]     ...future.result
[01:28:07.820] }
[01:28:07.823] assign_globals() ...
[01:28:07.824] List of 1
[01:28:07.824]  $ ii: int 1
[01:28:07.824]  - attr(*, "where")=List of 1
[01:28:07.824]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:07.824]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:07.824]  - attr(*, "resolved")= logi TRUE
[01:28:07.824]  - attr(*, "total_size")= num 56
[01:28:07.824]  - attr(*, "already-done")= logi TRUE
[01:28:07.827] - copied 'ii' to environment
[01:28:07.827] assign_globals() ... done
[01:28:07.827] plan(): Setting new future strategy stack:
[01:28:07.827] List of future strategies:
[01:28:07.827] 1. sequential:
[01:28:07.827]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.827]    - tweaked: FALSE
[01:28:07.827]    - call: NULL
[01:28:07.828] plan(): nbrOfWorkers() = 1
[01:28:07.829] plan(): Setting new future strategy stack:
[01:28:07.829] List of future strategies:
[01:28:07.829] 1. sequential:
[01:28:07.829]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.829]    - tweaked: FALSE
[01:28:07.829]    - call: plan(strategy)
[01:28:07.830] plan(): nbrOfWorkers() = 1
[01:28:07.830] SequentialFuture started (and completed)
[01:28:07.830] - Launch lazy future ... done
[01:28:07.831] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.831] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.832] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.833] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:07.834] Searching for globals ... DONE
[01:28:07.834] Resolving globals: TRUE
[01:28:07.834] Resolving any globals that are futures ...
[01:28:07.834] - globals: [4] '{', '<-', '*', 'ii'
[01:28:07.834] Resolving any globals that are futures ... DONE
[01:28:07.835] Resolving futures part of globals (recursively) ...
[01:28:07.837] resolve() on list ...
[01:28:07.837]  recursive: 99
[01:28:07.837]  length: 1
[01:28:07.837]  elements: 'ii'
[01:28:07.838]  length: 0 (resolved future 1)
[01:28:07.838] resolve() on list ... DONE
[01:28:07.838] - globals: [1] 'ii'
[01:28:07.838] Resolving futures part of globals (recursively) ... DONE
[01:28:07.838] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:07.839] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:07.839] - globals: [1] 'ii'
[01:28:07.839] 
[01:28:07.839] getGlobalsAndPackages() ... DONE
[01:28:07.840] run() for 'Future' ...
[01:28:07.840] - state: 'created'
[01:28:07.840] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.840] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.841] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.841]   - Field: 'label'
[01:28:07.841]   - Field: 'local'
[01:28:07.841]   - Field: 'owner'
[01:28:07.841]   - Field: 'envir'
[01:28:07.842]   - Field: 'packages'
[01:28:07.842]   - Field: 'gc'
[01:28:07.842]   - Field: 'conditions'
[01:28:07.842]   - Field: 'expr'
[01:28:07.842]   - Field: 'uuid'
[01:28:07.842]   - Field: 'seed'
[01:28:07.843]   - Field: 'version'
[01:28:07.843]   - Field: 'result'
[01:28:07.843]   - Field: 'asynchronous'
[01:28:07.843]   - Field: 'calls'
[01:28:07.843]   - Field: 'globals'
[01:28:07.844]   - Field: 'stdout'
[01:28:07.844]   - Field: 'earlySignal'
[01:28:07.844]   - Field: 'lazy'
[01:28:07.844]   - Field: 'state'
[01:28:07.844] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.844] - Launch lazy future ...
[01:28:07.845] Packages needed by the future expression (n = 0): <none>
[01:28:07.845] Packages needed by future strategies (n = 0): <none>
[01:28:07.845] {
[01:28:07.845]     {
[01:28:07.845]         {
[01:28:07.845]             ...future.startTime <- base::Sys.time()
[01:28:07.845]             {
[01:28:07.845]                 {
[01:28:07.845]                   {
[01:28:07.845]                     base::local({
[01:28:07.845]                       has_future <- base::requireNamespace("future", 
[01:28:07.845]                         quietly = TRUE)
[01:28:07.845]                       if (has_future) {
[01:28:07.845]                         ns <- base::getNamespace("future")
[01:28:07.845]                         version <- ns[[".package"]][["version"]]
[01:28:07.845]                         if (is.null(version)) 
[01:28:07.845]                           version <- utils::packageVersion("future")
[01:28:07.845]                       }
[01:28:07.845]                       else {
[01:28:07.845]                         version <- NULL
[01:28:07.845]                       }
[01:28:07.845]                       if (!has_future || version < "1.8.0") {
[01:28:07.845]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.845]                           "", base::R.version$version.string), 
[01:28:07.845]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.845]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.845]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.845]                             "release", "version")], collapse = " "), 
[01:28:07.845]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.845]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.845]                           info)
[01:28:07.845]                         info <- base::paste(info, collapse = "; ")
[01:28:07.845]                         if (!has_future) {
[01:28:07.845]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.845]                             info)
[01:28:07.845]                         }
[01:28:07.845]                         else {
[01:28:07.845]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.845]                             info, version)
[01:28:07.845]                         }
[01:28:07.845]                         base::stop(msg)
[01:28:07.845]                       }
[01:28:07.845]                     })
[01:28:07.845]                   }
[01:28:07.845]                   options(future.plan = NULL)
[01:28:07.845]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.845]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.845]                 }
[01:28:07.845]                 ...future.workdir <- getwd()
[01:28:07.845]             }
[01:28:07.845]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.845]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.845]         }
[01:28:07.845]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.845]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.845]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.845]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.845]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.845]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.845]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.845]             base::names(...future.oldOptions))
[01:28:07.845]     }
[01:28:07.845]     if (FALSE) {
[01:28:07.845]     }
[01:28:07.845]     else {
[01:28:07.845]         if (TRUE) {
[01:28:07.845]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.845]                 open = "w")
[01:28:07.845]         }
[01:28:07.845]         else {
[01:28:07.845]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.845]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.845]         }
[01:28:07.845]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.845]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.845]             base::sink(type = "output", split = FALSE)
[01:28:07.845]             base::close(...future.stdout)
[01:28:07.845]         }, add = TRUE)
[01:28:07.845]     }
[01:28:07.845]     ...future.frame <- base::sys.nframe()
[01:28:07.845]     ...future.conditions <- base::list()
[01:28:07.845]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.845]     if (FALSE) {
[01:28:07.845]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.845]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.845]     }
[01:28:07.845]     ...future.result <- base::tryCatch({
[01:28:07.845]         base::withCallingHandlers({
[01:28:07.845]             ...future.value <- base::withVisible(base::local({
[01:28:07.845]                 b <- a * ii
[01:28:07.845]                 a <- 0
[01:28:07.845]                 b
[01:28:07.845]             }))
[01:28:07.845]             future::FutureResult(value = ...future.value$value, 
[01:28:07.845]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.845]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.845]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.845]                     ...future.globalenv.names))
[01:28:07.845]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.845]         }, condition = base::local({
[01:28:07.845]             c <- base::c
[01:28:07.845]             inherits <- base::inherits
[01:28:07.845]             invokeRestart <- base::invokeRestart
[01:28:07.845]             length <- base::length
[01:28:07.845]             list <- base::list
[01:28:07.845]             seq.int <- base::seq.int
[01:28:07.845]             signalCondition <- base::signalCondition
[01:28:07.845]             sys.calls <- base::sys.calls
[01:28:07.845]             `[[` <- base::`[[`
[01:28:07.845]             `+` <- base::`+`
[01:28:07.845]             `<<-` <- base::`<<-`
[01:28:07.845]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.845]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.845]                   3L)]
[01:28:07.845]             }
[01:28:07.845]             function(cond) {
[01:28:07.845]                 is_error <- inherits(cond, "error")
[01:28:07.845]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.845]                   NULL)
[01:28:07.845]                 if (is_error) {
[01:28:07.845]                   sessionInformation <- function() {
[01:28:07.845]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.845]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.845]                       search = base::search(), system = base::Sys.info())
[01:28:07.845]                   }
[01:28:07.845]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.845]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.845]                     cond$call), session = sessionInformation(), 
[01:28:07.845]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.845]                   signalCondition(cond)
[01:28:07.845]                 }
[01:28:07.845]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.845]                 "immediateCondition"))) {
[01:28:07.845]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.845]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.845]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.845]                   if (TRUE && !signal) {
[01:28:07.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.845]                     {
[01:28:07.845]                       inherits <- base::inherits
[01:28:07.845]                       invokeRestart <- base::invokeRestart
[01:28:07.845]                       is.null <- base::is.null
[01:28:07.845]                       muffled <- FALSE
[01:28:07.845]                       if (inherits(cond, "message")) {
[01:28:07.845]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.845]                         if (muffled) 
[01:28:07.845]                           invokeRestart("muffleMessage")
[01:28:07.845]                       }
[01:28:07.845]                       else if (inherits(cond, "warning")) {
[01:28:07.845]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.845]                         if (muffled) 
[01:28:07.845]                           invokeRestart("muffleWarning")
[01:28:07.845]                       }
[01:28:07.845]                       else if (inherits(cond, "condition")) {
[01:28:07.845]                         if (!is.null(pattern)) {
[01:28:07.845]                           computeRestarts <- base::computeRestarts
[01:28:07.845]                           grepl <- base::grepl
[01:28:07.845]                           restarts <- computeRestarts(cond)
[01:28:07.845]                           for (restart in restarts) {
[01:28:07.845]                             name <- restart$name
[01:28:07.845]                             if (is.null(name)) 
[01:28:07.845]                               next
[01:28:07.845]                             if (!grepl(pattern, name)) 
[01:28:07.845]                               next
[01:28:07.845]                             invokeRestart(restart)
[01:28:07.845]                             muffled <- TRUE
[01:28:07.845]                             break
[01:28:07.845]                           }
[01:28:07.845]                         }
[01:28:07.845]                       }
[01:28:07.845]                       invisible(muffled)
[01:28:07.845]                     }
[01:28:07.845]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.845]                   }
[01:28:07.845]                 }
[01:28:07.845]                 else {
[01:28:07.845]                   if (TRUE) {
[01:28:07.845]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.845]                     {
[01:28:07.845]                       inherits <- base::inherits
[01:28:07.845]                       invokeRestart <- base::invokeRestart
[01:28:07.845]                       is.null <- base::is.null
[01:28:07.845]                       muffled <- FALSE
[01:28:07.845]                       if (inherits(cond, "message")) {
[01:28:07.845]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.845]                         if (muffled) 
[01:28:07.845]                           invokeRestart("muffleMessage")
[01:28:07.845]                       }
[01:28:07.845]                       else if (inherits(cond, "warning")) {
[01:28:07.845]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.845]                         if (muffled) 
[01:28:07.845]                           invokeRestart("muffleWarning")
[01:28:07.845]                       }
[01:28:07.845]                       else if (inherits(cond, "condition")) {
[01:28:07.845]                         if (!is.null(pattern)) {
[01:28:07.845]                           computeRestarts <- base::computeRestarts
[01:28:07.845]                           grepl <- base::grepl
[01:28:07.845]                           restarts <- computeRestarts(cond)
[01:28:07.845]                           for (restart in restarts) {
[01:28:07.845]                             name <- restart$name
[01:28:07.845]                             if (is.null(name)) 
[01:28:07.845]                               next
[01:28:07.845]                             if (!grepl(pattern, name)) 
[01:28:07.845]                               next
[01:28:07.845]                             invokeRestart(restart)
[01:28:07.845]                             muffled <- TRUE
[01:28:07.845]                             break
[01:28:07.845]                           }
[01:28:07.845]                         }
[01:28:07.845]                       }
[01:28:07.845]                       invisible(muffled)
[01:28:07.845]                     }
[01:28:07.845]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.845]                   }
[01:28:07.845]                 }
[01:28:07.845]             }
[01:28:07.845]         }))
[01:28:07.845]     }, error = function(ex) {
[01:28:07.845]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.845]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.845]                 ...future.rng), started = ...future.startTime, 
[01:28:07.845]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.845]             version = "1.8"), class = "FutureResult")
[01:28:07.845]     }, finally = {
[01:28:07.845]         if (!identical(...future.workdir, getwd())) 
[01:28:07.845]             setwd(...future.workdir)
[01:28:07.845]         {
[01:28:07.845]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.845]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.845]             }
[01:28:07.845]             base::options(...future.oldOptions)
[01:28:07.845]             if (.Platform$OS.type == "windows") {
[01:28:07.845]                 old_names <- names(...future.oldEnvVars)
[01:28:07.845]                 envs <- base::Sys.getenv()
[01:28:07.845]                 names <- names(envs)
[01:28:07.845]                 common <- intersect(names, old_names)
[01:28:07.845]                 added <- setdiff(names, old_names)
[01:28:07.845]                 removed <- setdiff(old_names, names)
[01:28:07.845]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.845]                   envs[common]]
[01:28:07.845]                 NAMES <- toupper(changed)
[01:28:07.845]                 args <- list()
[01:28:07.845]                 for (kk in seq_along(NAMES)) {
[01:28:07.845]                   name <- changed[[kk]]
[01:28:07.845]                   NAME <- NAMES[[kk]]
[01:28:07.845]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.845]                     next
[01:28:07.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.845]                 }
[01:28:07.845]                 NAMES <- toupper(added)
[01:28:07.845]                 for (kk in seq_along(NAMES)) {
[01:28:07.845]                   name <- added[[kk]]
[01:28:07.845]                   NAME <- NAMES[[kk]]
[01:28:07.845]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.845]                     next
[01:28:07.845]                   args[[name]] <- ""
[01:28:07.845]                 }
[01:28:07.845]                 NAMES <- toupper(removed)
[01:28:07.845]                 for (kk in seq_along(NAMES)) {
[01:28:07.845]                   name <- removed[[kk]]
[01:28:07.845]                   NAME <- NAMES[[kk]]
[01:28:07.845]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.845]                     next
[01:28:07.845]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.845]                 }
[01:28:07.845]                 if (length(args) > 0) 
[01:28:07.845]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.845]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.845]             }
[01:28:07.845]             else {
[01:28:07.845]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.845]             }
[01:28:07.845]             {
[01:28:07.845]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.845]                   0L) {
[01:28:07.845]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.845]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.845]                   base::options(opts)
[01:28:07.845]                 }
[01:28:07.845]                 {
[01:28:07.845]                   {
[01:28:07.845]                     NULL
[01:28:07.845]                     RNGkind("Mersenne-Twister")
[01:28:07.845]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.845]                       inherits = FALSE)
[01:28:07.845]                   }
[01:28:07.845]                   options(future.plan = NULL)
[01:28:07.845]                   if (is.na(NA_character_)) 
[01:28:07.845]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.845]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.845]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.845]                   {
[01:28:07.845]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.845]                     if (!future$lazy) 
[01:28:07.845]                       future <- run(future)
[01:28:07.845]                     invisible(future)
[01:28:07.845]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.845]                 }
[01:28:07.845]             }
[01:28:07.845]         }
[01:28:07.845]     })
[01:28:07.845]     if (TRUE) {
[01:28:07.845]         base::sink(type = "output", split = FALSE)
[01:28:07.845]         if (TRUE) {
[01:28:07.845]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.845]         }
[01:28:07.845]         else {
[01:28:07.845]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.845]         }
[01:28:07.845]         base::close(...future.stdout)
[01:28:07.845]         ...future.stdout <- NULL
[01:28:07.845]     }
[01:28:07.845]     ...future.result$conditions <- ...future.conditions
[01:28:07.845]     ...future.result$finished <- base::Sys.time()
[01:28:07.845]     ...future.result
[01:28:07.845] }
[01:28:07.849] assign_globals() ...
[01:28:07.849] List of 1
[01:28:07.849]  $ ii: int 2
[01:28:07.849]  - attr(*, "where")=List of 1
[01:28:07.849]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:07.849]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:07.849]  - attr(*, "resolved")= logi TRUE
[01:28:07.849]  - attr(*, "total_size")= num 56
[01:28:07.849]  - attr(*, "already-done")= logi TRUE
[01:28:07.852] - copied 'ii' to environment
[01:28:07.853] assign_globals() ... done
[01:28:07.853] plan(): Setting new future strategy stack:
[01:28:07.853] List of future strategies:
[01:28:07.853] 1. sequential:
[01:28:07.853]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.853]    - tweaked: FALSE
[01:28:07.853]    - call: NULL
[01:28:07.854] plan(): nbrOfWorkers() = 1
[01:28:07.855] plan(): Setting new future strategy stack:
[01:28:07.855] List of future strategies:
[01:28:07.855] 1. sequential:
[01:28:07.855]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.855]    - tweaked: FALSE
[01:28:07.855]    - call: plan(strategy)
[01:28:07.856] plan(): nbrOfWorkers() = 1
[01:28:07.856] SequentialFuture started (and completed)
[01:28:07.856] - Launch lazy future ... done
[01:28:07.857] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.857] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.858] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.859] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:07.859] Searching for globals ... DONE
[01:28:07.860] Resolving globals: TRUE
[01:28:07.860] Resolving any globals that are futures ...
[01:28:07.860] - globals: [4] '{', '<-', '*', 'ii'
[01:28:07.860] Resolving any globals that are futures ... DONE
[01:28:07.861] Resolving futures part of globals (recursively) ...
[01:28:07.861] resolve() on list ...
[01:28:07.861]  recursive: 99
[01:28:07.861]  length: 1
[01:28:07.861]  elements: 'ii'
[01:28:07.862]  length: 0 (resolved future 1)
[01:28:07.862] resolve() on list ... DONE
[01:28:07.862] - globals: [1] 'ii'
[01:28:07.862] Resolving futures part of globals (recursively) ... DONE
[01:28:07.862] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:07.863] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:07.863] - globals: [1] 'ii'
[01:28:07.863] 
[01:28:07.863] getGlobalsAndPackages() ... DONE
[01:28:07.863] run() for 'Future' ...
[01:28:07.864] - state: 'created'
[01:28:07.864] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.864] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.864] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.865]   - Field: 'label'
[01:28:07.865]   - Field: 'local'
[01:28:07.865]   - Field: 'owner'
[01:28:07.865]   - Field: 'envir'
[01:28:07.865]   - Field: 'packages'
[01:28:07.866]   - Field: 'gc'
[01:28:07.866]   - Field: 'conditions'
[01:28:07.866]   - Field: 'expr'
[01:28:07.866]   - Field: 'uuid'
[01:28:07.866]   - Field: 'seed'
[01:28:07.866]   - Field: 'version'
[01:28:07.867]   - Field: 'result'
[01:28:07.867]   - Field: 'asynchronous'
[01:28:07.867]   - Field: 'calls'
[01:28:07.867]   - Field: 'globals'
[01:28:07.867]   - Field: 'stdout'
[01:28:07.868]   - Field: 'earlySignal'
[01:28:07.868]   - Field: 'lazy'
[01:28:07.868]   - Field: 'state'
[01:28:07.868] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.868] - Launch lazy future ...
[01:28:07.868] Packages needed by the future expression (n = 0): <none>
[01:28:07.869] Packages needed by future strategies (n = 0): <none>
[01:28:07.869] {
[01:28:07.869]     {
[01:28:07.869]         {
[01:28:07.869]             ...future.startTime <- base::Sys.time()
[01:28:07.869]             {
[01:28:07.869]                 {
[01:28:07.869]                   {
[01:28:07.869]                     base::local({
[01:28:07.869]                       has_future <- base::requireNamespace("future", 
[01:28:07.869]                         quietly = TRUE)
[01:28:07.869]                       if (has_future) {
[01:28:07.869]                         ns <- base::getNamespace("future")
[01:28:07.869]                         version <- ns[[".package"]][["version"]]
[01:28:07.869]                         if (is.null(version)) 
[01:28:07.869]                           version <- utils::packageVersion("future")
[01:28:07.869]                       }
[01:28:07.869]                       else {
[01:28:07.869]                         version <- NULL
[01:28:07.869]                       }
[01:28:07.869]                       if (!has_future || version < "1.8.0") {
[01:28:07.869]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.869]                           "", base::R.version$version.string), 
[01:28:07.869]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.869]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.869]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.869]                             "release", "version")], collapse = " "), 
[01:28:07.869]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.869]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.869]                           info)
[01:28:07.869]                         info <- base::paste(info, collapse = "; ")
[01:28:07.869]                         if (!has_future) {
[01:28:07.869]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.869]                             info)
[01:28:07.869]                         }
[01:28:07.869]                         else {
[01:28:07.869]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.869]                             info, version)
[01:28:07.869]                         }
[01:28:07.869]                         base::stop(msg)
[01:28:07.869]                       }
[01:28:07.869]                     })
[01:28:07.869]                   }
[01:28:07.869]                   options(future.plan = NULL)
[01:28:07.869]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.869]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.869]                 }
[01:28:07.869]                 ...future.workdir <- getwd()
[01:28:07.869]             }
[01:28:07.869]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.869]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.869]         }
[01:28:07.869]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.869]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.869]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.869]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.869]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.869]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.869]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.869]             base::names(...future.oldOptions))
[01:28:07.869]     }
[01:28:07.869]     if (FALSE) {
[01:28:07.869]     }
[01:28:07.869]     else {
[01:28:07.869]         if (TRUE) {
[01:28:07.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.869]                 open = "w")
[01:28:07.869]         }
[01:28:07.869]         else {
[01:28:07.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.869]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.869]         }
[01:28:07.869]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.869]             base::sink(type = "output", split = FALSE)
[01:28:07.869]             base::close(...future.stdout)
[01:28:07.869]         }, add = TRUE)
[01:28:07.869]     }
[01:28:07.869]     ...future.frame <- base::sys.nframe()
[01:28:07.869]     ...future.conditions <- base::list()
[01:28:07.869]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.869]     if (FALSE) {
[01:28:07.869]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.869]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.869]     }
[01:28:07.869]     ...future.result <- base::tryCatch({
[01:28:07.869]         base::withCallingHandlers({
[01:28:07.869]             ...future.value <- base::withVisible(base::local({
[01:28:07.869]                 b <- a * ii
[01:28:07.869]                 a <- 0
[01:28:07.869]                 b
[01:28:07.869]             }))
[01:28:07.869]             future::FutureResult(value = ...future.value$value, 
[01:28:07.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.869]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.869]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.869]                     ...future.globalenv.names))
[01:28:07.869]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.869]         }, condition = base::local({
[01:28:07.869]             c <- base::c
[01:28:07.869]             inherits <- base::inherits
[01:28:07.869]             invokeRestart <- base::invokeRestart
[01:28:07.869]             length <- base::length
[01:28:07.869]             list <- base::list
[01:28:07.869]             seq.int <- base::seq.int
[01:28:07.869]             signalCondition <- base::signalCondition
[01:28:07.869]             sys.calls <- base::sys.calls
[01:28:07.869]             `[[` <- base::`[[`
[01:28:07.869]             `+` <- base::`+`
[01:28:07.869]             `<<-` <- base::`<<-`
[01:28:07.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.869]                   3L)]
[01:28:07.869]             }
[01:28:07.869]             function(cond) {
[01:28:07.869]                 is_error <- inherits(cond, "error")
[01:28:07.869]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.869]                   NULL)
[01:28:07.869]                 if (is_error) {
[01:28:07.869]                   sessionInformation <- function() {
[01:28:07.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.869]                       search = base::search(), system = base::Sys.info())
[01:28:07.869]                   }
[01:28:07.869]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.869]                     cond$call), session = sessionInformation(), 
[01:28:07.869]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.869]                   signalCondition(cond)
[01:28:07.869]                 }
[01:28:07.869]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.869]                 "immediateCondition"))) {
[01:28:07.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.869]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.869]                   if (TRUE && !signal) {
[01:28:07.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.869]                     {
[01:28:07.869]                       inherits <- base::inherits
[01:28:07.869]                       invokeRestart <- base::invokeRestart
[01:28:07.869]                       is.null <- base::is.null
[01:28:07.869]                       muffled <- FALSE
[01:28:07.869]                       if (inherits(cond, "message")) {
[01:28:07.869]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.869]                         if (muffled) 
[01:28:07.869]                           invokeRestart("muffleMessage")
[01:28:07.869]                       }
[01:28:07.869]                       else if (inherits(cond, "warning")) {
[01:28:07.869]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.869]                         if (muffled) 
[01:28:07.869]                           invokeRestart("muffleWarning")
[01:28:07.869]                       }
[01:28:07.869]                       else if (inherits(cond, "condition")) {
[01:28:07.869]                         if (!is.null(pattern)) {
[01:28:07.869]                           computeRestarts <- base::computeRestarts
[01:28:07.869]                           grepl <- base::grepl
[01:28:07.869]                           restarts <- computeRestarts(cond)
[01:28:07.869]                           for (restart in restarts) {
[01:28:07.869]                             name <- restart$name
[01:28:07.869]                             if (is.null(name)) 
[01:28:07.869]                               next
[01:28:07.869]                             if (!grepl(pattern, name)) 
[01:28:07.869]                               next
[01:28:07.869]                             invokeRestart(restart)
[01:28:07.869]                             muffled <- TRUE
[01:28:07.869]                             break
[01:28:07.869]                           }
[01:28:07.869]                         }
[01:28:07.869]                       }
[01:28:07.869]                       invisible(muffled)
[01:28:07.869]                     }
[01:28:07.869]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.869]                   }
[01:28:07.869]                 }
[01:28:07.869]                 else {
[01:28:07.869]                   if (TRUE) {
[01:28:07.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.869]                     {
[01:28:07.869]                       inherits <- base::inherits
[01:28:07.869]                       invokeRestart <- base::invokeRestart
[01:28:07.869]                       is.null <- base::is.null
[01:28:07.869]                       muffled <- FALSE
[01:28:07.869]                       if (inherits(cond, "message")) {
[01:28:07.869]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.869]                         if (muffled) 
[01:28:07.869]                           invokeRestart("muffleMessage")
[01:28:07.869]                       }
[01:28:07.869]                       else if (inherits(cond, "warning")) {
[01:28:07.869]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.869]                         if (muffled) 
[01:28:07.869]                           invokeRestart("muffleWarning")
[01:28:07.869]                       }
[01:28:07.869]                       else if (inherits(cond, "condition")) {
[01:28:07.869]                         if (!is.null(pattern)) {
[01:28:07.869]                           computeRestarts <- base::computeRestarts
[01:28:07.869]                           grepl <- base::grepl
[01:28:07.869]                           restarts <- computeRestarts(cond)
[01:28:07.869]                           for (restart in restarts) {
[01:28:07.869]                             name <- restart$name
[01:28:07.869]                             if (is.null(name)) 
[01:28:07.869]                               next
[01:28:07.869]                             if (!grepl(pattern, name)) 
[01:28:07.869]                               next
[01:28:07.869]                             invokeRestart(restart)
[01:28:07.869]                             muffled <- TRUE
[01:28:07.869]                             break
[01:28:07.869]                           }
[01:28:07.869]                         }
[01:28:07.869]                       }
[01:28:07.869]                       invisible(muffled)
[01:28:07.869]                     }
[01:28:07.869]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.869]                   }
[01:28:07.869]                 }
[01:28:07.869]             }
[01:28:07.869]         }))
[01:28:07.869]     }, error = function(ex) {
[01:28:07.869]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.869]                 ...future.rng), started = ...future.startTime, 
[01:28:07.869]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.869]             version = "1.8"), class = "FutureResult")
[01:28:07.869]     }, finally = {
[01:28:07.869]         if (!identical(...future.workdir, getwd())) 
[01:28:07.869]             setwd(...future.workdir)
[01:28:07.869]         {
[01:28:07.869]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.869]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.869]             }
[01:28:07.869]             base::options(...future.oldOptions)
[01:28:07.869]             if (.Platform$OS.type == "windows") {
[01:28:07.869]                 old_names <- names(...future.oldEnvVars)
[01:28:07.869]                 envs <- base::Sys.getenv()
[01:28:07.869]                 names <- names(envs)
[01:28:07.869]                 common <- intersect(names, old_names)
[01:28:07.869]                 added <- setdiff(names, old_names)
[01:28:07.869]                 removed <- setdiff(old_names, names)
[01:28:07.869]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.869]                   envs[common]]
[01:28:07.869]                 NAMES <- toupper(changed)
[01:28:07.869]                 args <- list()
[01:28:07.869]                 for (kk in seq_along(NAMES)) {
[01:28:07.869]                   name <- changed[[kk]]
[01:28:07.869]                   NAME <- NAMES[[kk]]
[01:28:07.869]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.869]                     next
[01:28:07.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.869]                 }
[01:28:07.869]                 NAMES <- toupper(added)
[01:28:07.869]                 for (kk in seq_along(NAMES)) {
[01:28:07.869]                   name <- added[[kk]]
[01:28:07.869]                   NAME <- NAMES[[kk]]
[01:28:07.869]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.869]                     next
[01:28:07.869]                   args[[name]] <- ""
[01:28:07.869]                 }
[01:28:07.869]                 NAMES <- toupper(removed)
[01:28:07.869]                 for (kk in seq_along(NAMES)) {
[01:28:07.869]                   name <- removed[[kk]]
[01:28:07.869]                   NAME <- NAMES[[kk]]
[01:28:07.869]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.869]                     next
[01:28:07.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.869]                 }
[01:28:07.869]                 if (length(args) > 0) 
[01:28:07.869]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.869]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.869]             }
[01:28:07.869]             else {
[01:28:07.869]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.869]             }
[01:28:07.869]             {
[01:28:07.869]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.869]                   0L) {
[01:28:07.869]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.869]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.869]                   base::options(opts)
[01:28:07.869]                 }
[01:28:07.869]                 {
[01:28:07.869]                   {
[01:28:07.869]                     NULL
[01:28:07.869]                     RNGkind("Mersenne-Twister")
[01:28:07.869]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.869]                       inherits = FALSE)
[01:28:07.869]                   }
[01:28:07.869]                   options(future.plan = NULL)
[01:28:07.869]                   if (is.na(NA_character_)) 
[01:28:07.869]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.869]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.869]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.869]                   {
[01:28:07.869]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.869]                     if (!future$lazy) 
[01:28:07.869]                       future <- run(future)
[01:28:07.869]                     invisible(future)
[01:28:07.869]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.869]                 }
[01:28:07.869]             }
[01:28:07.869]         }
[01:28:07.869]     })
[01:28:07.869]     if (TRUE) {
[01:28:07.869]         base::sink(type = "output", split = FALSE)
[01:28:07.869]         if (TRUE) {
[01:28:07.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.869]         }
[01:28:07.869]         else {
[01:28:07.869]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.869]         }
[01:28:07.869]         base::close(...future.stdout)
[01:28:07.869]         ...future.stdout <- NULL
[01:28:07.869]     }
[01:28:07.869]     ...future.result$conditions <- ...future.conditions
[01:28:07.869]     ...future.result$finished <- base::Sys.time()
[01:28:07.869]     ...future.result
[01:28:07.869] }
[01:28:07.873] assign_globals() ...
[01:28:07.873] List of 1
[01:28:07.873]  $ ii: int 3
[01:28:07.873]  - attr(*, "where")=List of 1
[01:28:07.873]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:07.873]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:07.873]  - attr(*, "resolved")= logi TRUE
[01:28:07.873]  - attr(*, "total_size")= num 56
[01:28:07.873]  - attr(*, "already-done")= logi TRUE
[01:28:07.878] - copied 'ii' to environment
[01:28:07.878] assign_globals() ... done
[01:28:07.878] plan(): Setting new future strategy stack:
[01:28:07.878] List of future strategies:
[01:28:07.878] 1. sequential:
[01:28:07.878]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.878]    - tweaked: FALSE
[01:28:07.878]    - call: NULL
[01:28:07.879] plan(): nbrOfWorkers() = 1
[01:28:07.880] plan(): Setting new future strategy stack:
[01:28:07.880] List of future strategies:
[01:28:07.880] 1. sequential:
[01:28:07.880]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.880]    - tweaked: FALSE
[01:28:07.880]    - call: plan(strategy)
[01:28:07.881] plan(): nbrOfWorkers() = 1
[01:28:07.881] SequentialFuture started (and completed)
[01:28:07.881] - Launch lazy future ... done
[01:28:07.881] run() for 'SequentialFuture' ... done
[1] 1 2 3
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.883] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.883] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.885] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:07.885] Searching for globals ... DONE
[01:28:07.885] Resolving globals: TRUE
[01:28:07.885] Resolving any globals that are futures ...
[01:28:07.886] - globals: [4] '{', '<-', '*', 'ii'
[01:28:07.886] Resolving any globals that are futures ... DONE
[01:28:07.886] Resolving futures part of globals (recursively) ...
[01:28:07.886] resolve() on list ...
[01:28:07.887]  recursive: 99
[01:28:07.887]  length: 1
[01:28:07.887]  elements: 'ii'
[01:28:07.887]  length: 0 (resolved future 1)
[01:28:07.887] resolve() on list ... DONE
[01:28:07.887] - globals: [1] 'ii'
[01:28:07.888] Resolving futures part of globals (recursively) ... DONE
[01:28:07.888] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:07.888] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:07.888] - globals: [1] 'ii'
[01:28:07.889] 
[01:28:07.889] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.890] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.890] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.891] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:07.892] Searching for globals ... DONE
[01:28:07.892] Resolving globals: TRUE
[01:28:07.892] Resolving any globals that are futures ...
[01:28:07.892] - globals: [4] '{', '<-', '*', 'ii'
[01:28:07.892] Resolving any globals that are futures ... DONE
[01:28:07.893] Resolving futures part of globals (recursively) ...
[01:28:07.893] resolve() on list ...
[01:28:07.893]  recursive: 99
[01:28:07.893]  length: 1
[01:28:07.894]  elements: 'ii'
[01:28:07.894]  length: 0 (resolved future 1)
[01:28:07.894] resolve() on list ... DONE
[01:28:07.894] - globals: [1] 'ii'
[01:28:07.894] Resolving futures part of globals (recursively) ... DONE
[01:28:07.894] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:07.895] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:07.895] - globals: [1] 'ii'
[01:28:07.895] 
[01:28:07.895] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.896] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.897] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.898] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:07.898] Searching for globals ... DONE
[01:28:07.898] Resolving globals: TRUE
[01:28:07.899] Resolving any globals that are futures ...
[01:28:07.899] - globals: [4] '{', '<-', '*', 'ii'
[01:28:07.899] Resolving any globals that are futures ... DONE
[01:28:07.899] Resolving futures part of globals (recursively) ...
[01:28:07.900] resolve() on list ...
[01:28:07.900]  recursive: 99
[01:28:07.900]  length: 1
[01:28:07.900]  elements: 'ii'
[01:28:07.900]  length: 0 (resolved future 1)
[01:28:07.901] resolve() on list ... DONE
[01:28:07.902] - globals: [1] 'ii'
[01:28:07.902] Resolving futures part of globals (recursively) ... DONE
[01:28:07.902] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:07.903] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:07.903] - globals: [1] 'ii'
[01:28:07.903] 
[01:28:07.903] getGlobalsAndPackages() ... DONE
[01:28:07.904] run() for 'Future' ...
[01:28:07.904] - state: 'created'
[01:28:07.904] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.905] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.905] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.905]   - Field: 'label'
[01:28:07.905]   - Field: 'local'
[01:28:07.905]   - Field: 'owner'
[01:28:07.905]   - Field: 'envir'
[01:28:07.906]   - Field: 'packages'
[01:28:07.906]   - Field: 'gc'
[01:28:07.906]   - Field: 'conditions'
[01:28:07.906]   - Field: 'expr'
[01:28:07.906]   - Field: 'uuid'
[01:28:07.907]   - Field: 'seed'
[01:28:07.907]   - Field: 'version'
[01:28:07.907]   - Field: 'result'
[01:28:07.907]   - Field: 'asynchronous'
[01:28:07.907]   - Field: 'calls'
[01:28:07.907]   - Field: 'globals'
[01:28:07.908]   - Field: 'stdout'
[01:28:07.908]   - Field: 'earlySignal'
[01:28:07.908]   - Field: 'lazy'
[01:28:07.908]   - Field: 'state'
[01:28:07.908] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.908] - Launch lazy future ...
[01:28:07.909] Packages needed by the future expression (n = 0): <none>
[01:28:07.909] Packages needed by future strategies (n = 0): <none>
[01:28:07.909] {
[01:28:07.909]     {
[01:28:07.909]         {
[01:28:07.909]             ...future.startTime <- base::Sys.time()
[01:28:07.909]             {
[01:28:07.909]                 {
[01:28:07.909]                   {
[01:28:07.909]                     base::local({
[01:28:07.909]                       has_future <- base::requireNamespace("future", 
[01:28:07.909]                         quietly = TRUE)
[01:28:07.909]                       if (has_future) {
[01:28:07.909]                         ns <- base::getNamespace("future")
[01:28:07.909]                         version <- ns[[".package"]][["version"]]
[01:28:07.909]                         if (is.null(version)) 
[01:28:07.909]                           version <- utils::packageVersion("future")
[01:28:07.909]                       }
[01:28:07.909]                       else {
[01:28:07.909]                         version <- NULL
[01:28:07.909]                       }
[01:28:07.909]                       if (!has_future || version < "1.8.0") {
[01:28:07.909]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.909]                           "", base::R.version$version.string), 
[01:28:07.909]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.909]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.909]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.909]                             "release", "version")], collapse = " "), 
[01:28:07.909]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.909]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.909]                           info)
[01:28:07.909]                         info <- base::paste(info, collapse = "; ")
[01:28:07.909]                         if (!has_future) {
[01:28:07.909]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.909]                             info)
[01:28:07.909]                         }
[01:28:07.909]                         else {
[01:28:07.909]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.909]                             info, version)
[01:28:07.909]                         }
[01:28:07.909]                         base::stop(msg)
[01:28:07.909]                       }
[01:28:07.909]                     })
[01:28:07.909]                   }
[01:28:07.909]                   options(future.plan = NULL)
[01:28:07.909]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.909]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.909]                 }
[01:28:07.909]                 ...future.workdir <- getwd()
[01:28:07.909]             }
[01:28:07.909]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.909]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.909]         }
[01:28:07.909]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.909]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.909]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.909]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.909]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.909]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.909]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.909]             base::names(...future.oldOptions))
[01:28:07.909]     }
[01:28:07.909]     if (FALSE) {
[01:28:07.909]     }
[01:28:07.909]     else {
[01:28:07.909]         if (TRUE) {
[01:28:07.909]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.909]                 open = "w")
[01:28:07.909]         }
[01:28:07.909]         else {
[01:28:07.909]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.909]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.909]         }
[01:28:07.909]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.909]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.909]             base::sink(type = "output", split = FALSE)
[01:28:07.909]             base::close(...future.stdout)
[01:28:07.909]         }, add = TRUE)
[01:28:07.909]     }
[01:28:07.909]     ...future.frame <- base::sys.nframe()
[01:28:07.909]     ...future.conditions <- base::list()
[01:28:07.909]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.909]     if (FALSE) {
[01:28:07.909]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.909]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.909]     }
[01:28:07.909]     ...future.result <- base::tryCatch({
[01:28:07.909]         base::withCallingHandlers({
[01:28:07.909]             ...future.value <- base::withVisible(base::local({
[01:28:07.909]                 b <- a * ii
[01:28:07.909]                 a <- 0
[01:28:07.909]                 b
[01:28:07.909]             }))
[01:28:07.909]             future::FutureResult(value = ...future.value$value, 
[01:28:07.909]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.909]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.909]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.909]                     ...future.globalenv.names))
[01:28:07.909]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.909]         }, condition = base::local({
[01:28:07.909]             c <- base::c
[01:28:07.909]             inherits <- base::inherits
[01:28:07.909]             invokeRestart <- base::invokeRestart
[01:28:07.909]             length <- base::length
[01:28:07.909]             list <- base::list
[01:28:07.909]             seq.int <- base::seq.int
[01:28:07.909]             signalCondition <- base::signalCondition
[01:28:07.909]             sys.calls <- base::sys.calls
[01:28:07.909]             `[[` <- base::`[[`
[01:28:07.909]             `+` <- base::`+`
[01:28:07.909]             `<<-` <- base::`<<-`
[01:28:07.909]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.909]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.909]                   3L)]
[01:28:07.909]             }
[01:28:07.909]             function(cond) {
[01:28:07.909]                 is_error <- inherits(cond, "error")
[01:28:07.909]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.909]                   NULL)
[01:28:07.909]                 if (is_error) {
[01:28:07.909]                   sessionInformation <- function() {
[01:28:07.909]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.909]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.909]                       search = base::search(), system = base::Sys.info())
[01:28:07.909]                   }
[01:28:07.909]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.909]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.909]                     cond$call), session = sessionInformation(), 
[01:28:07.909]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.909]                   signalCondition(cond)
[01:28:07.909]                 }
[01:28:07.909]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.909]                 "immediateCondition"))) {
[01:28:07.909]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.909]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.909]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.909]                   if (TRUE && !signal) {
[01:28:07.909]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.909]                     {
[01:28:07.909]                       inherits <- base::inherits
[01:28:07.909]                       invokeRestart <- base::invokeRestart
[01:28:07.909]                       is.null <- base::is.null
[01:28:07.909]                       muffled <- FALSE
[01:28:07.909]                       if (inherits(cond, "message")) {
[01:28:07.909]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.909]                         if (muffled) 
[01:28:07.909]                           invokeRestart("muffleMessage")
[01:28:07.909]                       }
[01:28:07.909]                       else if (inherits(cond, "warning")) {
[01:28:07.909]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.909]                         if (muffled) 
[01:28:07.909]                           invokeRestart("muffleWarning")
[01:28:07.909]                       }
[01:28:07.909]                       else if (inherits(cond, "condition")) {
[01:28:07.909]                         if (!is.null(pattern)) {
[01:28:07.909]                           computeRestarts <- base::computeRestarts
[01:28:07.909]                           grepl <- base::grepl
[01:28:07.909]                           restarts <- computeRestarts(cond)
[01:28:07.909]                           for (restart in restarts) {
[01:28:07.909]                             name <- restart$name
[01:28:07.909]                             if (is.null(name)) 
[01:28:07.909]                               next
[01:28:07.909]                             if (!grepl(pattern, name)) 
[01:28:07.909]                               next
[01:28:07.909]                             invokeRestart(restart)
[01:28:07.909]                             muffled <- TRUE
[01:28:07.909]                             break
[01:28:07.909]                           }
[01:28:07.909]                         }
[01:28:07.909]                       }
[01:28:07.909]                       invisible(muffled)
[01:28:07.909]                     }
[01:28:07.909]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.909]                   }
[01:28:07.909]                 }
[01:28:07.909]                 else {
[01:28:07.909]                   if (TRUE) {
[01:28:07.909]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.909]                     {
[01:28:07.909]                       inherits <- base::inherits
[01:28:07.909]                       invokeRestart <- base::invokeRestart
[01:28:07.909]                       is.null <- base::is.null
[01:28:07.909]                       muffled <- FALSE
[01:28:07.909]                       if (inherits(cond, "message")) {
[01:28:07.909]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.909]                         if (muffled) 
[01:28:07.909]                           invokeRestart("muffleMessage")
[01:28:07.909]                       }
[01:28:07.909]                       else if (inherits(cond, "warning")) {
[01:28:07.909]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.909]                         if (muffled) 
[01:28:07.909]                           invokeRestart("muffleWarning")
[01:28:07.909]                       }
[01:28:07.909]                       else if (inherits(cond, "condition")) {
[01:28:07.909]                         if (!is.null(pattern)) {
[01:28:07.909]                           computeRestarts <- base::computeRestarts
[01:28:07.909]                           grepl <- base::grepl
[01:28:07.909]                           restarts <- computeRestarts(cond)
[01:28:07.909]                           for (restart in restarts) {
[01:28:07.909]                             name <- restart$name
[01:28:07.909]                             if (is.null(name)) 
[01:28:07.909]                               next
[01:28:07.909]                             if (!grepl(pattern, name)) 
[01:28:07.909]                               next
[01:28:07.909]                             invokeRestart(restart)
[01:28:07.909]                             muffled <- TRUE
[01:28:07.909]                             break
[01:28:07.909]                           }
[01:28:07.909]                         }
[01:28:07.909]                       }
[01:28:07.909]                       invisible(muffled)
[01:28:07.909]                     }
[01:28:07.909]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.909]                   }
[01:28:07.909]                 }
[01:28:07.909]             }
[01:28:07.909]         }))
[01:28:07.909]     }, error = function(ex) {
[01:28:07.909]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.909]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.909]                 ...future.rng), started = ...future.startTime, 
[01:28:07.909]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.909]             version = "1.8"), class = "FutureResult")
[01:28:07.909]     }, finally = {
[01:28:07.909]         if (!identical(...future.workdir, getwd())) 
[01:28:07.909]             setwd(...future.workdir)
[01:28:07.909]         {
[01:28:07.909]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.909]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.909]             }
[01:28:07.909]             base::options(...future.oldOptions)
[01:28:07.909]             if (.Platform$OS.type == "windows") {
[01:28:07.909]                 old_names <- names(...future.oldEnvVars)
[01:28:07.909]                 envs <- base::Sys.getenv()
[01:28:07.909]                 names <- names(envs)
[01:28:07.909]                 common <- intersect(names, old_names)
[01:28:07.909]                 added <- setdiff(names, old_names)
[01:28:07.909]                 removed <- setdiff(old_names, names)
[01:28:07.909]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.909]                   envs[common]]
[01:28:07.909]                 NAMES <- toupper(changed)
[01:28:07.909]                 args <- list()
[01:28:07.909]                 for (kk in seq_along(NAMES)) {
[01:28:07.909]                   name <- changed[[kk]]
[01:28:07.909]                   NAME <- NAMES[[kk]]
[01:28:07.909]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.909]                     next
[01:28:07.909]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.909]                 }
[01:28:07.909]                 NAMES <- toupper(added)
[01:28:07.909]                 for (kk in seq_along(NAMES)) {
[01:28:07.909]                   name <- added[[kk]]
[01:28:07.909]                   NAME <- NAMES[[kk]]
[01:28:07.909]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.909]                     next
[01:28:07.909]                   args[[name]] <- ""
[01:28:07.909]                 }
[01:28:07.909]                 NAMES <- toupper(removed)
[01:28:07.909]                 for (kk in seq_along(NAMES)) {
[01:28:07.909]                   name <- removed[[kk]]
[01:28:07.909]                   NAME <- NAMES[[kk]]
[01:28:07.909]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.909]                     next
[01:28:07.909]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.909]                 }
[01:28:07.909]                 if (length(args) > 0) 
[01:28:07.909]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.909]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.909]             }
[01:28:07.909]             else {
[01:28:07.909]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.909]             }
[01:28:07.909]             {
[01:28:07.909]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.909]                   0L) {
[01:28:07.909]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.909]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.909]                   base::options(opts)
[01:28:07.909]                 }
[01:28:07.909]                 {
[01:28:07.909]                   {
[01:28:07.909]                     NULL
[01:28:07.909]                     RNGkind("Mersenne-Twister")
[01:28:07.909]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.909]                       inherits = FALSE)
[01:28:07.909]                   }
[01:28:07.909]                   options(future.plan = NULL)
[01:28:07.909]                   if (is.na(NA_character_)) 
[01:28:07.909]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.909]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.909]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.909]                   {
[01:28:07.909]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.909]                     if (!future$lazy) 
[01:28:07.909]                       future <- run(future)
[01:28:07.909]                     invisible(future)
[01:28:07.909]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.909]                 }
[01:28:07.909]             }
[01:28:07.909]         }
[01:28:07.909]     })
[01:28:07.909]     if (TRUE) {
[01:28:07.909]         base::sink(type = "output", split = FALSE)
[01:28:07.909]         if (TRUE) {
[01:28:07.909]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.909]         }
[01:28:07.909]         else {
[01:28:07.909]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.909]         }
[01:28:07.909]         base::close(...future.stdout)
[01:28:07.909]         ...future.stdout <- NULL
[01:28:07.909]     }
[01:28:07.909]     ...future.result$conditions <- ...future.conditions
[01:28:07.909]     ...future.result$finished <- base::Sys.time()
[01:28:07.909]     ...future.result
[01:28:07.909] }
[01:28:07.913] assign_globals() ...
[01:28:07.913] List of 1
[01:28:07.913]  $ ii: int 1
[01:28:07.913]  - attr(*, "where")=List of 1
[01:28:07.913]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:07.913]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:07.913]  - attr(*, "resolved")= logi TRUE
[01:28:07.913]  - attr(*, "total_size")= num 56
[01:28:07.913]  - attr(*, "already-done")= logi TRUE
[01:28:07.916] - copied 'ii' to environment
[01:28:07.916] assign_globals() ... done
[01:28:07.917] plan(): Setting new future strategy stack:
[01:28:07.917] List of future strategies:
[01:28:07.917] 1. sequential:
[01:28:07.917]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.917]    - tweaked: FALSE
[01:28:07.917]    - call: NULL
[01:28:07.918] plan(): nbrOfWorkers() = 1
[01:28:07.919] plan(): Setting new future strategy stack:
[01:28:07.919] List of future strategies:
[01:28:07.919] 1. sequential:
[01:28:07.919]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.919]    - tweaked: FALSE
[01:28:07.919]    - call: plan(strategy)
[01:28:07.920] plan(): nbrOfWorkers() = 1
[01:28:07.920] SequentialFuture started (and completed)
[01:28:07.920] signalConditions() ...
[01:28:07.920]  - include = 'immediateCondition'
[01:28:07.920]  - exclude = 
[01:28:07.921]  - resignal = FALSE
[01:28:07.921]  - Number of conditions: 1
[01:28:07.921] signalConditions() ... done
[01:28:07.921] - Launch lazy future ... done
[01:28:07.921] run() for 'SequentialFuture' ... done
[01:28:07.922] signalConditions() ...
[01:28:07.922]  - include = 'immediateCondition'
[01:28:07.922]  - exclude = 
[01:28:07.922]  - resignal = FALSE
[01:28:07.922]  - Number of conditions: 1
[01:28:07.922] signalConditions() ... done
[01:28:07.923] Future state: 'finished'
[01:28:07.923] signalConditions() ...
[01:28:07.923]  - include = 'condition'
[01:28:07.923]  - exclude = 'immediateCondition'
[01:28:07.923]  - resignal = TRUE
[01:28:07.923]  - Number of conditions: 1
[01:28:07.924]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:07.924] signalConditions() ... done
List of 1
 $ res: 'try-error' chr "Error in eval(quote({ : object 'a' not found\n"
  ..- attr(*, "condition")=List of 3
  .. ..$ message    : chr "object 'a' not found"
  .. ..$ call       : language eval(quote({     b <- a * ii ...
  .. ..$ future.info:List of 5
  .. .. ..$ condition:List of 2
  .. .. .. ..$ message: chr "object 'a' not found"
  .. .. .. ..$ call   : language eval(quote({     b <- a * ii ...
  .. .. .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  .. .. ..$ calls    :List of 11
  .. .. .. ..$ : language res[[ii]] %<-% {     b <- a * ii ...
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language res[[ii]] %<-% {     b <- a * ii ...
  .. .. .. ..$ : language futureAssignInternal(target, expr, envir = envir, substitute = FALSE)
  .. .. .. ..$ : language futureAssign(name, expr, envir = envir, assign.env = assign.env, substitute = FALSE)
  .. .. .. ..$ : language do.call(future::future, args = future.args, envir = assign.env)
  .. .. .. ..$ : language (function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE,      seed = FALSE, globals = TRUE, pack| __truncated__ ...
  .. .. .. ..$ : language Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, seed = seed,      globals = globals, packages = pack| __truncated__ ...
  .. .. .. ..$ : language eval(quote({     b <- a * ii ...
  .. .. .. ..$ : language eval(quote({     b <- a * ii ...
  .. .. ..$ session  :List of 6
  .. .. .. ..$ r         :List of 15
  .. .. .. .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. .. .. .. ..$ arch          : chr "x86_64"
  .. .. .. .. ..$ os            : chr "mingw32"
  .. .. .. .. ..$ crt           : chr "ucrt"
  .. .. .. .. ..$ system        : chr "x86_64, mingw32"
  .. .. .. .. ..$ status        : chr "Under development (unstable)"
  .. .. .. .. ..$ major         : chr "4"
  .. .. .. .. ..$ minor         : chr "4.0"
  .. .. .. .. ..$ year          : chr "2023"
  .. .. .. .. ..$ month         : chr "12"
  .. .. .. .. ..$ day           : chr "20"
  .. .. .. .. ..$ svn rev       : chr "85713"
  .. .. .. .. ..$ language      : chr "R"
  .. .. .. .. ..$ version.string: chr "R Under development (unstable) (2023-12-20 r85713 ucrt)"
  .. .. .. .. ..$ nickname      : chr "Unsuffered Consequences"
  .. .. .. ..$ locale    : chr "LC_COLLATE=C;LC_CTYPE=German_Germany.utf8;LC_MONETARY=C;LC_NUMERIC=C;LC_TIME=C"
  .. .. .. ..$ rngkind   : chr [1:3] "Mersenne-Twister" "Inversion" "Rejection"
  .. .. .. ..$ namespaces: chr [1:16] "compiler" "parallelly" "graphics" "tools" ...
  .. .. .. ..$ search    : chr [1:11] ".GlobalEnv" "package:listenv" "package:future" "package:stats" ...
  .. .. .. ..$ system    : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. .. ..$ timestamp: POSIXct[1:1], format: "2023-12-22 01:28:07"
  .. .. ..$ signaled : int 1
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.942] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.942] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.943] 
[01:28:07.943] Searching for globals ... DONE
[01:28:07.943] - globals: [0] <none>
[01:28:07.944] getGlobalsAndPackages() ... DONE
[01:28:07.944] run() for 'Future' ...
[01:28:07.944] - state: 'created'
[01:28:07.944] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.945] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.945] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.945]   - Field: 'label'
[01:28:07.945]   - Field: 'local'
[01:28:07.945]   - Field: 'owner'
[01:28:07.946]   - Field: 'envir'
[01:28:07.946]   - Field: 'packages'
[01:28:07.946]   - Field: 'gc'
[01:28:07.946]   - Field: 'conditions'
[01:28:07.946]   - Field: 'expr'
[01:28:07.946]   - Field: 'uuid'
[01:28:07.947]   - Field: 'seed'
[01:28:07.947]   - Field: 'version'
[01:28:07.947]   - Field: 'result'
[01:28:07.947]   - Field: 'asynchronous'
[01:28:07.947]   - Field: 'calls'
[01:28:07.948]   - Field: 'globals'
[01:28:07.948]   - Field: 'stdout'
[01:28:07.948]   - Field: 'earlySignal'
[01:28:07.948]   - Field: 'lazy'
[01:28:07.949]   - Field: 'state'
[01:28:07.949] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.949] - Launch lazy future ...
[01:28:07.950] Packages needed by the future expression (n = 0): <none>
[01:28:07.950] Packages needed by future strategies (n = 0): <none>
[01:28:07.950] {
[01:28:07.950]     {
[01:28:07.950]         {
[01:28:07.950]             ...future.startTime <- base::Sys.time()
[01:28:07.950]             {
[01:28:07.950]                 {
[01:28:07.950]                   {
[01:28:07.950]                     base::local({
[01:28:07.950]                       has_future <- base::requireNamespace("future", 
[01:28:07.950]                         quietly = TRUE)
[01:28:07.950]                       if (has_future) {
[01:28:07.950]                         ns <- base::getNamespace("future")
[01:28:07.950]                         version <- ns[[".package"]][["version"]]
[01:28:07.950]                         if (is.null(version)) 
[01:28:07.950]                           version <- utils::packageVersion("future")
[01:28:07.950]                       }
[01:28:07.950]                       else {
[01:28:07.950]                         version <- NULL
[01:28:07.950]                       }
[01:28:07.950]                       if (!has_future || version < "1.8.0") {
[01:28:07.950]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.950]                           "", base::R.version$version.string), 
[01:28:07.950]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.950]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.950]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.950]                             "release", "version")], collapse = " "), 
[01:28:07.950]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.950]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.950]                           info)
[01:28:07.950]                         info <- base::paste(info, collapse = "; ")
[01:28:07.950]                         if (!has_future) {
[01:28:07.950]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.950]                             info)
[01:28:07.950]                         }
[01:28:07.950]                         else {
[01:28:07.950]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.950]                             info, version)
[01:28:07.950]                         }
[01:28:07.950]                         base::stop(msg)
[01:28:07.950]                       }
[01:28:07.950]                     })
[01:28:07.950]                   }
[01:28:07.950]                   options(future.plan = NULL)
[01:28:07.950]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.950]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.950]                 }
[01:28:07.950]                 ...future.workdir <- getwd()
[01:28:07.950]             }
[01:28:07.950]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.950]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.950]         }
[01:28:07.950]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.950]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.950]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.950]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.950]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.950]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.950]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.950]             base::names(...future.oldOptions))
[01:28:07.950]     }
[01:28:07.950]     if (FALSE) {
[01:28:07.950]     }
[01:28:07.950]     else {
[01:28:07.950]         if (TRUE) {
[01:28:07.950]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.950]                 open = "w")
[01:28:07.950]         }
[01:28:07.950]         else {
[01:28:07.950]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.950]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.950]         }
[01:28:07.950]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.950]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.950]             base::sink(type = "output", split = FALSE)
[01:28:07.950]             base::close(...future.stdout)
[01:28:07.950]         }, add = TRUE)
[01:28:07.950]     }
[01:28:07.950]     ...future.frame <- base::sys.nframe()
[01:28:07.950]     ...future.conditions <- base::list()
[01:28:07.950]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.950]     if (FALSE) {
[01:28:07.950]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.950]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.950]     }
[01:28:07.950]     ...future.result <- base::tryCatch({
[01:28:07.950]         base::withCallingHandlers({
[01:28:07.950]             ...future.value <- base::withVisible(base::local(1))
[01:28:07.950]             future::FutureResult(value = ...future.value$value, 
[01:28:07.950]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.950]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.950]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.950]                     ...future.globalenv.names))
[01:28:07.950]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.950]         }, condition = base::local({
[01:28:07.950]             c <- base::c
[01:28:07.950]             inherits <- base::inherits
[01:28:07.950]             invokeRestart <- base::invokeRestart
[01:28:07.950]             length <- base::length
[01:28:07.950]             list <- base::list
[01:28:07.950]             seq.int <- base::seq.int
[01:28:07.950]             signalCondition <- base::signalCondition
[01:28:07.950]             sys.calls <- base::sys.calls
[01:28:07.950]             `[[` <- base::`[[`
[01:28:07.950]             `+` <- base::`+`
[01:28:07.950]             `<<-` <- base::`<<-`
[01:28:07.950]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.950]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.950]                   3L)]
[01:28:07.950]             }
[01:28:07.950]             function(cond) {
[01:28:07.950]                 is_error <- inherits(cond, "error")
[01:28:07.950]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.950]                   NULL)
[01:28:07.950]                 if (is_error) {
[01:28:07.950]                   sessionInformation <- function() {
[01:28:07.950]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.950]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.950]                       search = base::search(), system = base::Sys.info())
[01:28:07.950]                   }
[01:28:07.950]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.950]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.950]                     cond$call), session = sessionInformation(), 
[01:28:07.950]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.950]                   signalCondition(cond)
[01:28:07.950]                 }
[01:28:07.950]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.950]                 "immediateCondition"))) {
[01:28:07.950]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.950]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.950]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.950]                   if (TRUE && !signal) {
[01:28:07.950]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.950]                     {
[01:28:07.950]                       inherits <- base::inherits
[01:28:07.950]                       invokeRestart <- base::invokeRestart
[01:28:07.950]                       is.null <- base::is.null
[01:28:07.950]                       muffled <- FALSE
[01:28:07.950]                       if (inherits(cond, "message")) {
[01:28:07.950]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.950]                         if (muffled) 
[01:28:07.950]                           invokeRestart("muffleMessage")
[01:28:07.950]                       }
[01:28:07.950]                       else if (inherits(cond, "warning")) {
[01:28:07.950]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.950]                         if (muffled) 
[01:28:07.950]                           invokeRestart("muffleWarning")
[01:28:07.950]                       }
[01:28:07.950]                       else if (inherits(cond, "condition")) {
[01:28:07.950]                         if (!is.null(pattern)) {
[01:28:07.950]                           computeRestarts <- base::computeRestarts
[01:28:07.950]                           grepl <- base::grepl
[01:28:07.950]                           restarts <- computeRestarts(cond)
[01:28:07.950]                           for (restart in restarts) {
[01:28:07.950]                             name <- restart$name
[01:28:07.950]                             if (is.null(name)) 
[01:28:07.950]                               next
[01:28:07.950]                             if (!grepl(pattern, name)) 
[01:28:07.950]                               next
[01:28:07.950]                             invokeRestart(restart)
[01:28:07.950]                             muffled <- TRUE
[01:28:07.950]                             break
[01:28:07.950]                           }
[01:28:07.950]                         }
[01:28:07.950]                       }
[01:28:07.950]                       invisible(muffled)
[01:28:07.950]                     }
[01:28:07.950]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.950]                   }
[01:28:07.950]                 }
[01:28:07.950]                 else {
[01:28:07.950]                   if (TRUE) {
[01:28:07.950]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.950]                     {
[01:28:07.950]                       inherits <- base::inherits
[01:28:07.950]                       invokeRestart <- base::invokeRestart
[01:28:07.950]                       is.null <- base::is.null
[01:28:07.950]                       muffled <- FALSE
[01:28:07.950]                       if (inherits(cond, "message")) {
[01:28:07.950]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.950]                         if (muffled) 
[01:28:07.950]                           invokeRestart("muffleMessage")
[01:28:07.950]                       }
[01:28:07.950]                       else if (inherits(cond, "warning")) {
[01:28:07.950]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.950]                         if (muffled) 
[01:28:07.950]                           invokeRestart("muffleWarning")
[01:28:07.950]                       }
[01:28:07.950]                       else if (inherits(cond, "condition")) {
[01:28:07.950]                         if (!is.null(pattern)) {
[01:28:07.950]                           computeRestarts <- base::computeRestarts
[01:28:07.950]                           grepl <- base::grepl
[01:28:07.950]                           restarts <- computeRestarts(cond)
[01:28:07.950]                           for (restart in restarts) {
[01:28:07.950]                             name <- restart$name
[01:28:07.950]                             if (is.null(name)) 
[01:28:07.950]                               next
[01:28:07.950]                             if (!grepl(pattern, name)) 
[01:28:07.950]                               next
[01:28:07.950]                             invokeRestart(restart)
[01:28:07.950]                             muffled <- TRUE
[01:28:07.950]                             break
[01:28:07.950]                           }
[01:28:07.950]                         }
[01:28:07.950]                       }
[01:28:07.950]                       invisible(muffled)
[01:28:07.950]                     }
[01:28:07.950]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.950]                   }
[01:28:07.950]                 }
[01:28:07.950]             }
[01:28:07.950]         }))
[01:28:07.950]     }, error = function(ex) {
[01:28:07.950]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.950]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.950]                 ...future.rng), started = ...future.startTime, 
[01:28:07.950]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.950]             version = "1.8"), class = "FutureResult")
[01:28:07.950]     }, finally = {
[01:28:07.950]         if (!identical(...future.workdir, getwd())) 
[01:28:07.950]             setwd(...future.workdir)
[01:28:07.950]         {
[01:28:07.950]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.950]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.950]             }
[01:28:07.950]             base::options(...future.oldOptions)
[01:28:07.950]             if (.Platform$OS.type == "windows") {
[01:28:07.950]                 old_names <- names(...future.oldEnvVars)
[01:28:07.950]                 envs <- base::Sys.getenv()
[01:28:07.950]                 names <- names(envs)
[01:28:07.950]                 common <- intersect(names, old_names)
[01:28:07.950]                 added <- setdiff(names, old_names)
[01:28:07.950]                 removed <- setdiff(old_names, names)
[01:28:07.950]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.950]                   envs[common]]
[01:28:07.950]                 NAMES <- toupper(changed)
[01:28:07.950]                 args <- list()
[01:28:07.950]                 for (kk in seq_along(NAMES)) {
[01:28:07.950]                   name <- changed[[kk]]
[01:28:07.950]                   NAME <- NAMES[[kk]]
[01:28:07.950]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.950]                     next
[01:28:07.950]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.950]                 }
[01:28:07.950]                 NAMES <- toupper(added)
[01:28:07.950]                 for (kk in seq_along(NAMES)) {
[01:28:07.950]                   name <- added[[kk]]
[01:28:07.950]                   NAME <- NAMES[[kk]]
[01:28:07.950]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.950]                     next
[01:28:07.950]                   args[[name]] <- ""
[01:28:07.950]                 }
[01:28:07.950]                 NAMES <- toupper(removed)
[01:28:07.950]                 for (kk in seq_along(NAMES)) {
[01:28:07.950]                   name <- removed[[kk]]
[01:28:07.950]                   NAME <- NAMES[[kk]]
[01:28:07.950]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.950]                     next
[01:28:07.950]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.950]                 }
[01:28:07.950]                 if (length(args) > 0) 
[01:28:07.950]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.950]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.950]             }
[01:28:07.950]             else {
[01:28:07.950]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.950]             }
[01:28:07.950]             {
[01:28:07.950]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.950]                   0L) {
[01:28:07.950]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.950]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.950]                   base::options(opts)
[01:28:07.950]                 }
[01:28:07.950]                 {
[01:28:07.950]                   {
[01:28:07.950]                     NULL
[01:28:07.950]                     RNGkind("Mersenne-Twister")
[01:28:07.950]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.950]                       inherits = FALSE)
[01:28:07.950]                   }
[01:28:07.950]                   options(future.plan = NULL)
[01:28:07.950]                   if (is.na(NA_character_)) 
[01:28:07.950]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.950]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.950]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.950]                   {
[01:28:07.950]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.950]                     if (!future$lazy) 
[01:28:07.950]                       future <- run(future)
[01:28:07.950]                     invisible(future)
[01:28:07.950]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.950]                 }
[01:28:07.950]             }
[01:28:07.950]         }
[01:28:07.950]     })
[01:28:07.950]     if (TRUE) {
[01:28:07.950]         base::sink(type = "output", split = FALSE)
[01:28:07.950]         if (TRUE) {
[01:28:07.950]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.950]         }
[01:28:07.950]         else {
[01:28:07.950]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.950]         }
[01:28:07.950]         base::close(...future.stdout)
[01:28:07.950]         ...future.stdout <- NULL
[01:28:07.950]     }
[01:28:07.950]     ...future.result$conditions <- ...future.conditions
[01:28:07.950]     ...future.result$finished <- base::Sys.time()
[01:28:07.950]     ...future.result
[01:28:07.950] }
[01:28:07.954] plan(): Setting new future strategy stack:
[01:28:07.954] List of future strategies:
[01:28:07.954] 1. sequential:
[01:28:07.954]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.954]    - tweaked: FALSE
[01:28:07.954]    - call: NULL
[01:28:07.955] plan(): nbrOfWorkers() = 1
[01:28:07.956] plan(): Setting new future strategy stack:
[01:28:07.956] List of future strategies:
[01:28:07.956] 1. sequential:
[01:28:07.956]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.956]    - tweaked: FALSE
[01:28:07.956]    - call: plan(strategy)
[01:28:07.957] plan(): nbrOfWorkers() = 1
[01:28:07.957] SequentialFuture started (and completed)
[01:28:07.958] - Launch lazy future ... done
[01:28:07.958] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.958] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.958] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.959] - globals found: [3] '+', 'value', 'a'
[01:28:07.960] Searching for globals ... DONE
[01:28:07.960] Resolving globals: TRUE
[01:28:07.960] Resolving any globals that are futures ...
[01:28:07.960] - globals: [3] '+', 'value', 'a'
[01:28:07.960] Resolving any globals that are futures ... DONE
[01:28:07.961] Resolving futures part of globals (recursively) ...
[01:28:07.961] resolve() on list ...
[01:28:07.961]  recursive: 99
[01:28:07.961]  length: 1
[01:28:07.962]  elements: 'a'
[01:28:07.962] resolved() for 'SequentialFuture' ...
[01:28:07.962] - state: 'finished'
[01:28:07.962] - run: TRUE
[01:28:07.962] - result: 'FutureResult'
[01:28:07.963] resolved() for 'SequentialFuture' ... done
[01:28:07.963] Future #1
[01:28:07.963] resolved() for 'SequentialFuture' ...
[01:28:07.964] - state: 'finished'
[01:28:07.964] - run: TRUE
[01:28:07.964] - result: 'FutureResult'
[01:28:07.964] resolved() for 'SequentialFuture' ... done
[01:28:07.964] A SequentialFuture was resolved
[01:28:07.966]  length: 0 (resolved future 1)
[01:28:07.966] resolve() on list ... DONE
[01:28:07.966] - globals: [1] 'a'
[01:28:07.966] Resolving futures part of globals (recursively) ... DONE
[01:28:07.967] The total size of the 1 globals is 9.95 KiB (10184 bytes)
[01:28:07.968] The total size of the 1 globals exported for future expression ('value(a) + 1') is 9.95 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (9.95 KiB of class 'environment')
[01:28:07.968] - globals: [1] 'a'
[01:28:07.968] - packages: [1] 'future'
[01:28:07.968] getGlobalsAndPackages() ... DONE
[01:28:07.969] run() for 'Future' ...
[01:28:07.969] - state: 'created'
[01:28:07.969] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.969] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.970] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.970]   - Field: 'label'
[01:28:07.970]   - Field: 'local'
[01:28:07.970]   - Field: 'owner'
[01:28:07.970]   - Field: 'envir'
[01:28:07.971]   - Field: 'packages'
[01:28:07.971]   - Field: 'gc'
[01:28:07.971]   - Field: 'conditions'
[01:28:07.971]   - Field: 'expr'
[01:28:07.971]   - Field: 'uuid'
[01:28:07.971]   - Field: 'seed'
[01:28:07.972]   - Field: 'version'
[01:28:07.972]   - Field: 'result'
[01:28:07.972]   - Field: 'asynchronous'
[01:28:07.972]   - Field: 'calls'
[01:28:07.972]   - Field: 'globals'
[01:28:07.972]   - Field: 'stdout'
[01:28:07.973]   - Field: 'earlySignal'
[01:28:07.973]   - Field: 'lazy'
[01:28:07.973]   - Field: 'state'
[01:28:07.973] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.973] - Launch lazy future ...
[01:28:07.974] Packages needed by the future expression (n = 1): 'future'
[01:28:07.974] Packages needed by future strategies (n = 0): <none>
[01:28:07.974] {
[01:28:07.974]     {
[01:28:07.974]         {
[01:28:07.974]             ...future.startTime <- base::Sys.time()
[01:28:07.974]             {
[01:28:07.974]                 {
[01:28:07.974]                   {
[01:28:07.974]                     {
[01:28:07.974]                       base::local({
[01:28:07.974]                         has_future <- base::requireNamespace("future", 
[01:28:07.974]                           quietly = TRUE)
[01:28:07.974]                         if (has_future) {
[01:28:07.974]                           ns <- base::getNamespace("future")
[01:28:07.974]                           version <- ns[[".package"]][["version"]]
[01:28:07.974]                           if (is.null(version)) 
[01:28:07.974]                             version <- utils::packageVersion("future")
[01:28:07.974]                         }
[01:28:07.974]                         else {
[01:28:07.974]                           version <- NULL
[01:28:07.974]                         }
[01:28:07.974]                         if (!has_future || version < "1.8.0") {
[01:28:07.974]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.974]                             "", base::R.version$version.string), 
[01:28:07.974]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:07.974]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.974]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.974]                               "release", "version")], collapse = " "), 
[01:28:07.974]                             hostname = base::Sys.info()[["nodename"]])
[01:28:07.974]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.974]                             info)
[01:28:07.974]                           info <- base::paste(info, collapse = "; ")
[01:28:07.974]                           if (!has_future) {
[01:28:07.974]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.974]                               info)
[01:28:07.974]                           }
[01:28:07.974]                           else {
[01:28:07.974]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.974]                               info, version)
[01:28:07.974]                           }
[01:28:07.974]                           base::stop(msg)
[01:28:07.974]                         }
[01:28:07.974]                       })
[01:28:07.974]                     }
[01:28:07.974]                     base::local({
[01:28:07.974]                       for (pkg in "future") {
[01:28:07.974]                         base::loadNamespace(pkg)
[01:28:07.974]                         base::library(pkg, character.only = TRUE)
[01:28:07.974]                       }
[01:28:07.974]                     })
[01:28:07.974]                   }
[01:28:07.974]                   options(future.plan = NULL)
[01:28:07.974]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.974]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.974]                 }
[01:28:07.974]                 ...future.workdir <- getwd()
[01:28:07.974]             }
[01:28:07.974]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.974]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.974]         }
[01:28:07.974]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.974]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.974]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.974]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.974]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.974]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.974]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.974]             base::names(...future.oldOptions))
[01:28:07.974]     }
[01:28:07.974]     if (FALSE) {
[01:28:07.974]     }
[01:28:07.974]     else {
[01:28:07.974]         if (TRUE) {
[01:28:07.974]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.974]                 open = "w")
[01:28:07.974]         }
[01:28:07.974]         else {
[01:28:07.974]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.974]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.974]         }
[01:28:07.974]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.974]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.974]             base::sink(type = "output", split = FALSE)
[01:28:07.974]             base::close(...future.stdout)
[01:28:07.974]         }, add = TRUE)
[01:28:07.974]     }
[01:28:07.974]     ...future.frame <- base::sys.nframe()
[01:28:07.974]     ...future.conditions <- base::list()
[01:28:07.974]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.974]     if (FALSE) {
[01:28:07.974]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.974]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.974]     }
[01:28:07.974]     ...future.result <- base::tryCatch({
[01:28:07.974]         base::withCallingHandlers({
[01:28:07.974]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:07.974]                 1))
[01:28:07.974]             future::FutureResult(value = ...future.value$value, 
[01:28:07.974]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.974]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.974]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.974]                     ...future.globalenv.names))
[01:28:07.974]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.974]         }, condition = base::local({
[01:28:07.974]             c <- base::c
[01:28:07.974]             inherits <- base::inherits
[01:28:07.974]             invokeRestart <- base::invokeRestart
[01:28:07.974]             length <- base::length
[01:28:07.974]             list <- base::list
[01:28:07.974]             seq.int <- base::seq.int
[01:28:07.974]             signalCondition <- base::signalCondition
[01:28:07.974]             sys.calls <- base::sys.calls
[01:28:07.974]             `[[` <- base::`[[`
[01:28:07.974]             `+` <- base::`+`
[01:28:07.974]             `<<-` <- base::`<<-`
[01:28:07.974]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.974]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.974]                   3L)]
[01:28:07.974]             }
[01:28:07.974]             function(cond) {
[01:28:07.974]                 is_error <- inherits(cond, "error")
[01:28:07.974]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.974]                   NULL)
[01:28:07.974]                 if (is_error) {
[01:28:07.974]                   sessionInformation <- function() {
[01:28:07.974]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.974]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.974]                       search = base::search(), system = base::Sys.info())
[01:28:07.974]                   }
[01:28:07.974]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.974]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.974]                     cond$call), session = sessionInformation(), 
[01:28:07.974]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.974]                   signalCondition(cond)
[01:28:07.974]                 }
[01:28:07.974]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.974]                 "immediateCondition"))) {
[01:28:07.974]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.974]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.974]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.974]                   if (TRUE && !signal) {
[01:28:07.974]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.974]                     {
[01:28:07.974]                       inherits <- base::inherits
[01:28:07.974]                       invokeRestart <- base::invokeRestart
[01:28:07.974]                       is.null <- base::is.null
[01:28:07.974]                       muffled <- FALSE
[01:28:07.974]                       if (inherits(cond, "message")) {
[01:28:07.974]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.974]                         if (muffled) 
[01:28:07.974]                           invokeRestart("muffleMessage")
[01:28:07.974]                       }
[01:28:07.974]                       else if (inherits(cond, "warning")) {
[01:28:07.974]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.974]                         if (muffled) 
[01:28:07.974]                           invokeRestart("muffleWarning")
[01:28:07.974]                       }
[01:28:07.974]                       else if (inherits(cond, "condition")) {
[01:28:07.974]                         if (!is.null(pattern)) {
[01:28:07.974]                           computeRestarts <- base::computeRestarts
[01:28:07.974]                           grepl <- base::grepl
[01:28:07.974]                           restarts <- computeRestarts(cond)
[01:28:07.974]                           for (restart in restarts) {
[01:28:07.974]                             name <- restart$name
[01:28:07.974]                             if (is.null(name)) 
[01:28:07.974]                               next
[01:28:07.974]                             if (!grepl(pattern, name)) 
[01:28:07.974]                               next
[01:28:07.974]                             invokeRestart(restart)
[01:28:07.974]                             muffled <- TRUE
[01:28:07.974]                             break
[01:28:07.974]                           }
[01:28:07.974]                         }
[01:28:07.974]                       }
[01:28:07.974]                       invisible(muffled)
[01:28:07.974]                     }
[01:28:07.974]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.974]                   }
[01:28:07.974]                 }
[01:28:07.974]                 else {
[01:28:07.974]                   if (TRUE) {
[01:28:07.974]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.974]                     {
[01:28:07.974]                       inherits <- base::inherits
[01:28:07.974]                       invokeRestart <- base::invokeRestart
[01:28:07.974]                       is.null <- base::is.null
[01:28:07.974]                       muffled <- FALSE
[01:28:07.974]                       if (inherits(cond, "message")) {
[01:28:07.974]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.974]                         if (muffled) 
[01:28:07.974]                           invokeRestart("muffleMessage")
[01:28:07.974]                       }
[01:28:07.974]                       else if (inherits(cond, "warning")) {
[01:28:07.974]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.974]                         if (muffled) 
[01:28:07.974]                           invokeRestart("muffleWarning")
[01:28:07.974]                       }
[01:28:07.974]                       else if (inherits(cond, "condition")) {
[01:28:07.974]                         if (!is.null(pattern)) {
[01:28:07.974]                           computeRestarts <- base::computeRestarts
[01:28:07.974]                           grepl <- base::grepl
[01:28:07.974]                           restarts <- computeRestarts(cond)
[01:28:07.974]                           for (restart in restarts) {
[01:28:07.974]                             name <- restart$name
[01:28:07.974]                             if (is.null(name)) 
[01:28:07.974]                               next
[01:28:07.974]                             if (!grepl(pattern, name)) 
[01:28:07.974]                               next
[01:28:07.974]                             invokeRestart(restart)
[01:28:07.974]                             muffled <- TRUE
[01:28:07.974]                             break
[01:28:07.974]                           }
[01:28:07.974]                         }
[01:28:07.974]                       }
[01:28:07.974]                       invisible(muffled)
[01:28:07.974]                     }
[01:28:07.974]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.974]                   }
[01:28:07.974]                 }
[01:28:07.974]             }
[01:28:07.974]         }))
[01:28:07.974]     }, error = function(ex) {
[01:28:07.974]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.974]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.974]                 ...future.rng), started = ...future.startTime, 
[01:28:07.974]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.974]             version = "1.8"), class = "FutureResult")
[01:28:07.974]     }, finally = {
[01:28:07.974]         if (!identical(...future.workdir, getwd())) 
[01:28:07.974]             setwd(...future.workdir)
[01:28:07.974]         {
[01:28:07.974]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.974]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.974]             }
[01:28:07.974]             base::options(...future.oldOptions)
[01:28:07.974]             if (.Platform$OS.type == "windows") {
[01:28:07.974]                 old_names <- names(...future.oldEnvVars)
[01:28:07.974]                 envs <- base::Sys.getenv()
[01:28:07.974]                 names <- names(envs)
[01:28:07.974]                 common <- intersect(names, old_names)
[01:28:07.974]                 added <- setdiff(names, old_names)
[01:28:07.974]                 removed <- setdiff(old_names, names)
[01:28:07.974]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.974]                   envs[common]]
[01:28:07.974]                 NAMES <- toupper(changed)
[01:28:07.974]                 args <- list()
[01:28:07.974]                 for (kk in seq_along(NAMES)) {
[01:28:07.974]                   name <- changed[[kk]]
[01:28:07.974]                   NAME <- NAMES[[kk]]
[01:28:07.974]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.974]                     next
[01:28:07.974]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.974]                 }
[01:28:07.974]                 NAMES <- toupper(added)
[01:28:07.974]                 for (kk in seq_along(NAMES)) {
[01:28:07.974]                   name <- added[[kk]]
[01:28:07.974]                   NAME <- NAMES[[kk]]
[01:28:07.974]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.974]                     next
[01:28:07.974]                   args[[name]] <- ""
[01:28:07.974]                 }
[01:28:07.974]                 NAMES <- toupper(removed)
[01:28:07.974]                 for (kk in seq_along(NAMES)) {
[01:28:07.974]                   name <- removed[[kk]]
[01:28:07.974]                   NAME <- NAMES[[kk]]
[01:28:07.974]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.974]                     next
[01:28:07.974]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.974]                 }
[01:28:07.974]                 if (length(args) > 0) 
[01:28:07.974]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.974]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.974]             }
[01:28:07.974]             else {
[01:28:07.974]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.974]             }
[01:28:07.974]             {
[01:28:07.974]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.974]                   0L) {
[01:28:07.974]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.974]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.974]                   base::options(opts)
[01:28:07.974]                 }
[01:28:07.974]                 {
[01:28:07.974]                   {
[01:28:07.974]                     NULL
[01:28:07.974]                     RNGkind("Mersenne-Twister")
[01:28:07.974]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.974]                       inherits = FALSE)
[01:28:07.974]                   }
[01:28:07.974]                   options(future.plan = NULL)
[01:28:07.974]                   if (is.na(NA_character_)) 
[01:28:07.974]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.974]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.974]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.974]                   {
[01:28:07.974]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.974]                     if (!future$lazy) 
[01:28:07.974]                       future <- run(future)
[01:28:07.974]                     invisible(future)
[01:28:07.974]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.974]                 }
[01:28:07.974]             }
[01:28:07.974]         }
[01:28:07.974]     })
[01:28:07.974]     if (TRUE) {
[01:28:07.974]         base::sink(type = "output", split = FALSE)
[01:28:07.974]         if (TRUE) {
[01:28:07.974]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.974]         }
[01:28:07.974]         else {
[01:28:07.974]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.974]         }
[01:28:07.974]         base::close(...future.stdout)
[01:28:07.974]         ...future.stdout <- NULL
[01:28:07.974]     }
[01:28:07.974]     ...future.result$conditions <- ...future.conditions
[01:28:07.974]     ...future.result$finished <- base::Sys.time()
[01:28:07.974]     ...future.result
[01:28:07.974] }
[01:28:07.978] assign_globals() ...
[01:28:07.978] List of 1
[01:28:07.978]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d8090650> 
[01:28:07.978]  - attr(*, "where")=List of 1
[01:28:07.978]   ..$ a:<environment: R_EmptyEnv> 
[01:28:07.978]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:07.978]  - attr(*, "resolved")= logi TRUE
[01:28:07.978]  - attr(*, "total_size")= num 10184
[01:28:07.978]  - attr(*, "already-done")= logi TRUE
[01:28:07.981] - copied 'a' to environment
[01:28:07.982] assign_globals() ... done
[01:28:07.982] plan(): Setting new future strategy stack:
[01:28:07.982] List of future strategies:
[01:28:07.982] 1. sequential:
[01:28:07.982]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.982]    - tweaked: FALSE
[01:28:07.982]    - call: NULL
[01:28:07.983] plan(): nbrOfWorkers() = 1
[01:28:07.984] plan(): Setting new future strategy stack:
[01:28:07.984] List of future strategies:
[01:28:07.984] 1. sequential:
[01:28:07.984]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.984]    - tweaked: FALSE
[01:28:07.984]    - call: plan(strategy)
[01:28:07.985] plan(): nbrOfWorkers() = 1
[01:28:07.985] SequentialFuture started (and completed)
[01:28:07.986] - Launch lazy future ... done
[01:28:07.986] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:07.986] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:07.987] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:07.987] 
[01:28:07.987] Searching for globals ... DONE
[01:28:07.988] - globals: [0] <none>
[01:28:07.988] getGlobalsAndPackages() ... DONE
[01:28:07.988] run() for 'Future' ...
[01:28:07.988] - state: 'created'
[01:28:07.989] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:07.989] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:07.989] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:07.989]   - Field: 'label'
[01:28:07.989]   - Field: 'local'
[01:28:07.990]   - Field: 'owner'
[01:28:07.990]   - Field: 'envir'
[01:28:07.990]   - Field: 'packages'
[01:28:07.990]   - Field: 'gc'
[01:28:07.990]   - Field: 'conditions'
[01:28:07.990]   - Field: 'expr'
[01:28:07.991]   - Field: 'uuid'
[01:28:07.991]   - Field: 'seed'
[01:28:07.991]   - Field: 'version'
[01:28:07.991]   - Field: 'result'
[01:28:07.991]   - Field: 'asynchronous'
[01:28:07.992]   - Field: 'calls'
[01:28:07.992]   - Field: 'globals'
[01:28:07.992]   - Field: 'stdout'
[01:28:07.992]   - Field: 'earlySignal'
[01:28:07.992]   - Field: 'lazy'
[01:28:07.992]   - Field: 'state'
[01:28:07.993] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:07.993] - Launch lazy future ...
[01:28:07.993] Packages needed by the future expression (n = 0): <none>
[01:28:07.993] Packages needed by future strategies (n = 0): <none>
[01:28:07.994] {
[01:28:07.994]     {
[01:28:07.994]         {
[01:28:07.994]             ...future.startTime <- base::Sys.time()
[01:28:07.994]             {
[01:28:07.994]                 {
[01:28:07.994]                   {
[01:28:07.994]                     base::local({
[01:28:07.994]                       has_future <- base::requireNamespace("future", 
[01:28:07.994]                         quietly = TRUE)
[01:28:07.994]                       if (has_future) {
[01:28:07.994]                         ns <- base::getNamespace("future")
[01:28:07.994]                         version <- ns[[".package"]][["version"]]
[01:28:07.994]                         if (is.null(version)) 
[01:28:07.994]                           version <- utils::packageVersion("future")
[01:28:07.994]                       }
[01:28:07.994]                       else {
[01:28:07.994]                         version <- NULL
[01:28:07.994]                       }
[01:28:07.994]                       if (!has_future || version < "1.8.0") {
[01:28:07.994]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:07.994]                           "", base::R.version$version.string), 
[01:28:07.994]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:07.994]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:07.994]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:07.994]                             "release", "version")], collapse = " "), 
[01:28:07.994]                           hostname = base::Sys.info()[["nodename"]])
[01:28:07.994]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:07.994]                           info)
[01:28:07.994]                         info <- base::paste(info, collapse = "; ")
[01:28:07.994]                         if (!has_future) {
[01:28:07.994]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:07.994]                             info)
[01:28:07.994]                         }
[01:28:07.994]                         else {
[01:28:07.994]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:07.994]                             info, version)
[01:28:07.994]                         }
[01:28:07.994]                         base::stop(msg)
[01:28:07.994]                       }
[01:28:07.994]                     })
[01:28:07.994]                   }
[01:28:07.994]                   options(future.plan = NULL)
[01:28:07.994]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.994]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:07.994]                 }
[01:28:07.994]                 ...future.workdir <- getwd()
[01:28:07.994]             }
[01:28:07.994]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:07.994]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:07.994]         }
[01:28:07.994]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:07.994]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:07.994]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:07.994]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:07.994]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:07.994]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:07.994]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:07.994]             base::names(...future.oldOptions))
[01:28:07.994]     }
[01:28:07.994]     if (FALSE) {
[01:28:07.994]     }
[01:28:07.994]     else {
[01:28:07.994]         if (TRUE) {
[01:28:07.994]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:07.994]                 open = "w")
[01:28:07.994]         }
[01:28:07.994]         else {
[01:28:07.994]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:07.994]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:07.994]         }
[01:28:07.994]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:07.994]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:07.994]             base::sink(type = "output", split = FALSE)
[01:28:07.994]             base::close(...future.stdout)
[01:28:07.994]         }, add = TRUE)
[01:28:07.994]     }
[01:28:07.994]     ...future.frame <- base::sys.nframe()
[01:28:07.994]     ...future.conditions <- base::list()
[01:28:07.994]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:07.994]     if (FALSE) {
[01:28:07.994]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:07.994]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:07.994]     }
[01:28:07.994]     ...future.result <- base::tryCatch({
[01:28:07.994]         base::withCallingHandlers({
[01:28:07.994]             ...future.value <- base::withVisible(base::local(1))
[01:28:07.994]             future::FutureResult(value = ...future.value$value, 
[01:28:07.994]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.994]                   ...future.rng), globalenv = if (FALSE) 
[01:28:07.994]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:07.994]                     ...future.globalenv.names))
[01:28:07.994]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:07.994]         }, condition = base::local({
[01:28:07.994]             c <- base::c
[01:28:07.994]             inherits <- base::inherits
[01:28:07.994]             invokeRestart <- base::invokeRestart
[01:28:07.994]             length <- base::length
[01:28:07.994]             list <- base::list
[01:28:07.994]             seq.int <- base::seq.int
[01:28:07.994]             signalCondition <- base::signalCondition
[01:28:07.994]             sys.calls <- base::sys.calls
[01:28:07.994]             `[[` <- base::`[[`
[01:28:07.994]             `+` <- base::`+`
[01:28:07.994]             `<<-` <- base::`<<-`
[01:28:07.994]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:07.994]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:07.994]                   3L)]
[01:28:07.994]             }
[01:28:07.994]             function(cond) {
[01:28:07.994]                 is_error <- inherits(cond, "error")
[01:28:07.994]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:07.994]                   NULL)
[01:28:07.994]                 if (is_error) {
[01:28:07.994]                   sessionInformation <- function() {
[01:28:07.994]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:07.994]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:07.994]                       search = base::search(), system = base::Sys.info())
[01:28:07.994]                   }
[01:28:07.994]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.994]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:07.994]                     cond$call), session = sessionInformation(), 
[01:28:07.994]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:07.994]                   signalCondition(cond)
[01:28:07.994]                 }
[01:28:07.994]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:07.994]                 "immediateCondition"))) {
[01:28:07.994]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:07.994]                   ...future.conditions[[length(...future.conditions) + 
[01:28:07.994]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:07.994]                   if (TRUE && !signal) {
[01:28:07.994]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.994]                     {
[01:28:07.994]                       inherits <- base::inherits
[01:28:07.994]                       invokeRestart <- base::invokeRestart
[01:28:07.994]                       is.null <- base::is.null
[01:28:07.994]                       muffled <- FALSE
[01:28:07.994]                       if (inherits(cond, "message")) {
[01:28:07.994]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.994]                         if (muffled) 
[01:28:07.994]                           invokeRestart("muffleMessage")
[01:28:07.994]                       }
[01:28:07.994]                       else if (inherits(cond, "warning")) {
[01:28:07.994]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.994]                         if (muffled) 
[01:28:07.994]                           invokeRestart("muffleWarning")
[01:28:07.994]                       }
[01:28:07.994]                       else if (inherits(cond, "condition")) {
[01:28:07.994]                         if (!is.null(pattern)) {
[01:28:07.994]                           computeRestarts <- base::computeRestarts
[01:28:07.994]                           grepl <- base::grepl
[01:28:07.994]                           restarts <- computeRestarts(cond)
[01:28:07.994]                           for (restart in restarts) {
[01:28:07.994]                             name <- restart$name
[01:28:07.994]                             if (is.null(name)) 
[01:28:07.994]                               next
[01:28:07.994]                             if (!grepl(pattern, name)) 
[01:28:07.994]                               next
[01:28:07.994]                             invokeRestart(restart)
[01:28:07.994]                             muffled <- TRUE
[01:28:07.994]                             break
[01:28:07.994]                           }
[01:28:07.994]                         }
[01:28:07.994]                       }
[01:28:07.994]                       invisible(muffled)
[01:28:07.994]                     }
[01:28:07.994]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.994]                   }
[01:28:07.994]                 }
[01:28:07.994]                 else {
[01:28:07.994]                   if (TRUE) {
[01:28:07.994]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:07.994]                     {
[01:28:07.994]                       inherits <- base::inherits
[01:28:07.994]                       invokeRestart <- base::invokeRestart
[01:28:07.994]                       is.null <- base::is.null
[01:28:07.994]                       muffled <- FALSE
[01:28:07.994]                       if (inherits(cond, "message")) {
[01:28:07.994]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:07.994]                         if (muffled) 
[01:28:07.994]                           invokeRestart("muffleMessage")
[01:28:07.994]                       }
[01:28:07.994]                       else if (inherits(cond, "warning")) {
[01:28:07.994]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:07.994]                         if (muffled) 
[01:28:07.994]                           invokeRestart("muffleWarning")
[01:28:07.994]                       }
[01:28:07.994]                       else if (inherits(cond, "condition")) {
[01:28:07.994]                         if (!is.null(pattern)) {
[01:28:07.994]                           computeRestarts <- base::computeRestarts
[01:28:07.994]                           grepl <- base::grepl
[01:28:07.994]                           restarts <- computeRestarts(cond)
[01:28:07.994]                           for (restart in restarts) {
[01:28:07.994]                             name <- restart$name
[01:28:07.994]                             if (is.null(name)) 
[01:28:07.994]                               next
[01:28:07.994]                             if (!grepl(pattern, name)) 
[01:28:07.994]                               next
[01:28:07.994]                             invokeRestart(restart)
[01:28:07.994]                             muffled <- TRUE
[01:28:07.994]                             break
[01:28:07.994]                           }
[01:28:07.994]                         }
[01:28:07.994]                       }
[01:28:07.994]                       invisible(muffled)
[01:28:07.994]                     }
[01:28:07.994]                     muffleCondition(cond, pattern = "^muffle")
[01:28:07.994]                   }
[01:28:07.994]                 }
[01:28:07.994]             }
[01:28:07.994]         }))
[01:28:07.994]     }, error = function(ex) {
[01:28:07.994]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:07.994]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:07.994]                 ...future.rng), started = ...future.startTime, 
[01:28:07.994]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:07.994]             version = "1.8"), class = "FutureResult")
[01:28:07.994]     }, finally = {
[01:28:07.994]         if (!identical(...future.workdir, getwd())) 
[01:28:07.994]             setwd(...future.workdir)
[01:28:07.994]         {
[01:28:07.994]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:07.994]                 ...future.oldOptions$nwarnings <- NULL
[01:28:07.994]             }
[01:28:07.994]             base::options(...future.oldOptions)
[01:28:07.994]             if (.Platform$OS.type == "windows") {
[01:28:07.994]                 old_names <- names(...future.oldEnvVars)
[01:28:07.994]                 envs <- base::Sys.getenv()
[01:28:07.994]                 names <- names(envs)
[01:28:07.994]                 common <- intersect(names, old_names)
[01:28:07.994]                 added <- setdiff(names, old_names)
[01:28:07.994]                 removed <- setdiff(old_names, names)
[01:28:07.994]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:07.994]                   envs[common]]
[01:28:07.994]                 NAMES <- toupper(changed)
[01:28:07.994]                 args <- list()
[01:28:07.994]                 for (kk in seq_along(NAMES)) {
[01:28:07.994]                   name <- changed[[kk]]
[01:28:07.994]                   NAME <- NAMES[[kk]]
[01:28:07.994]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.994]                     next
[01:28:07.994]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.994]                 }
[01:28:07.994]                 NAMES <- toupper(added)
[01:28:07.994]                 for (kk in seq_along(NAMES)) {
[01:28:07.994]                   name <- added[[kk]]
[01:28:07.994]                   NAME <- NAMES[[kk]]
[01:28:07.994]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.994]                     next
[01:28:07.994]                   args[[name]] <- ""
[01:28:07.994]                 }
[01:28:07.994]                 NAMES <- toupper(removed)
[01:28:07.994]                 for (kk in seq_along(NAMES)) {
[01:28:07.994]                   name <- removed[[kk]]
[01:28:07.994]                   NAME <- NAMES[[kk]]
[01:28:07.994]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:07.994]                     next
[01:28:07.994]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:07.994]                 }
[01:28:07.994]                 if (length(args) > 0) 
[01:28:07.994]                   base::do.call(base::Sys.setenv, args = args)
[01:28:07.994]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:07.994]             }
[01:28:07.994]             else {
[01:28:07.994]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:07.994]             }
[01:28:07.994]             {
[01:28:07.994]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:07.994]                   0L) {
[01:28:07.994]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:07.994]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:07.994]                   base::options(opts)
[01:28:07.994]                 }
[01:28:07.994]                 {
[01:28:07.994]                   {
[01:28:07.994]                     NULL
[01:28:07.994]                     RNGkind("Mersenne-Twister")
[01:28:07.994]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:07.994]                       inherits = FALSE)
[01:28:07.994]                   }
[01:28:07.994]                   options(future.plan = NULL)
[01:28:07.994]                   if (is.na(NA_character_)) 
[01:28:07.994]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:07.994]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:07.994]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:07.994]                   {
[01:28:07.994]                     future <- SequentialFuture(..., envir = envir)
[01:28:07.994]                     if (!future$lazy) 
[01:28:07.994]                       future <- run(future)
[01:28:07.994]                     invisible(future)
[01:28:07.994]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:07.994]                 }
[01:28:07.994]             }
[01:28:07.994]         }
[01:28:07.994]     })
[01:28:07.994]     if (TRUE) {
[01:28:07.994]         base::sink(type = "output", split = FALSE)
[01:28:07.994]         if (TRUE) {
[01:28:07.994]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:07.994]         }
[01:28:07.994]         else {
[01:28:07.994]             ...future.result["stdout"] <- base::list(NULL)
[01:28:07.994]         }
[01:28:07.994]         base::close(...future.stdout)
[01:28:07.994]         ...future.stdout <- NULL
[01:28:07.994]     }
[01:28:07.994]     ...future.result$conditions <- ...future.conditions
[01:28:07.994]     ...future.result$finished <- base::Sys.time()
[01:28:07.994]     ...future.result
[01:28:07.994] }
[01:28:07.998] plan(): Setting new future strategy stack:
[01:28:07.998] List of future strategies:
[01:28:07.998] 1. sequential:
[01:28:07.998]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:07.998]    - tweaked: FALSE
[01:28:07.998]    - call: NULL
[01:28:07.998] plan(): nbrOfWorkers() = 1
[01:28:08.000] plan(): Setting new future strategy stack:
[01:28:08.000] List of future strategies:
[01:28:08.000] 1. sequential:
[01:28:08.000]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.000]    - tweaked: FALSE
[01:28:08.000]    - call: plan(strategy)
[01:28:08.000] plan(): nbrOfWorkers() = 1
[01:28:08.001] SequentialFuture started (and completed)
[01:28:08.001] - Launch lazy future ... done
[01:28:08.001] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.003] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.003] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:08.004] - globals found: [3] '+', 'value', 'a'
[01:28:08.004] Searching for globals ... DONE
[01:28:08.005] Resolving globals: TRUE
[01:28:08.005] Resolving any globals that are futures ...
[01:28:08.005] - globals: [3] '+', 'value', 'a'
[01:28:08.005] Resolving any globals that are futures ... DONE
[01:28:08.006] Resolving futures part of globals (recursively) ...
[01:28:08.006] resolve() on list ...
[01:28:08.006]  recursive: 99
[01:28:08.006]  length: 1
[01:28:08.006]  elements: 'a'
[01:28:08.007] resolved() for 'SequentialFuture' ...
[01:28:08.007] - state: 'finished'
[01:28:08.007] - run: TRUE
[01:28:08.007] - result: 'FutureResult'
[01:28:08.007] resolved() for 'SequentialFuture' ... done
[01:28:08.007] Future #1
[01:28:08.008] resolved() for 'SequentialFuture' ...
[01:28:08.008] - state: 'finished'
[01:28:08.008] - run: TRUE
[01:28:08.008] - result: 'FutureResult'
[01:28:08.008] resolved() for 'SequentialFuture' ... done
[01:28:08.009] A SequentialFuture was resolved
[01:28:08.009]  length: 0 (resolved future 1)
[01:28:08.009] resolve() on list ... DONE
[01:28:08.009] - globals: [1] 'a'
[01:28:08.009] Resolving futures part of globals (recursively) ... DONE
[01:28:08.010] The total size of the 1 globals is 9.95 KiB (10184 bytes)
[01:28:08.011] The total size of the 1 globals exported for future expression ('value(a) + 1') is 9.95 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (9.95 KiB of class 'environment')
[01:28:08.011] - globals: [1] 'a'
[01:28:08.011] - packages: [1] 'future'
[01:28:08.011] getGlobalsAndPackages() ... DONE
[01:28:08.012] run() for 'Future' ...
[01:28:08.012] - state: 'created'
[01:28:08.012] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.013] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.013] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.013]   - Field: 'label'
[01:28:08.013]   - Field: 'local'
[01:28:08.013]   - Field: 'owner'
[01:28:08.014]   - Field: 'envir'
[01:28:08.014]   - Field: 'packages'
[01:28:08.014]   - Field: 'gc'
[01:28:08.014]   - Field: 'conditions'
[01:28:08.014]   - Field: 'expr'
[01:28:08.014]   - Field: 'uuid'
[01:28:08.015]   - Field: 'seed'
[01:28:08.015]   - Field: 'version'
[01:28:08.015]   - Field: 'result'
[01:28:08.015]   - Field: 'asynchronous'
[01:28:08.015]   - Field: 'calls'
[01:28:08.015]   - Field: 'globals'
[01:28:08.016]   - Field: 'stdout'
[01:28:08.016]   - Field: 'earlySignal'
[01:28:08.016]   - Field: 'lazy'
[01:28:08.016]   - Field: 'state'
[01:28:08.016] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.017] - Launch lazy future ...
[01:28:08.017] Packages needed by the future expression (n = 1): 'future'
[01:28:08.017] Packages needed by future strategies (n = 0): <none>
[01:28:08.018] {
[01:28:08.018]     {
[01:28:08.018]         {
[01:28:08.018]             ...future.startTime <- base::Sys.time()
[01:28:08.018]             {
[01:28:08.018]                 {
[01:28:08.018]                   {
[01:28:08.018]                     {
[01:28:08.018]                       base::local({
[01:28:08.018]                         has_future <- base::requireNamespace("future", 
[01:28:08.018]                           quietly = TRUE)
[01:28:08.018]                         if (has_future) {
[01:28:08.018]                           ns <- base::getNamespace("future")
[01:28:08.018]                           version <- ns[[".package"]][["version"]]
[01:28:08.018]                           if (is.null(version)) 
[01:28:08.018]                             version <- utils::packageVersion("future")
[01:28:08.018]                         }
[01:28:08.018]                         else {
[01:28:08.018]                           version <- NULL
[01:28:08.018]                         }
[01:28:08.018]                         if (!has_future || version < "1.8.0") {
[01:28:08.018]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.018]                             "", base::R.version$version.string), 
[01:28:08.018]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.018]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.018]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.018]                               "release", "version")], collapse = " "), 
[01:28:08.018]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.018]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.018]                             info)
[01:28:08.018]                           info <- base::paste(info, collapse = "; ")
[01:28:08.018]                           if (!has_future) {
[01:28:08.018]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.018]                               info)
[01:28:08.018]                           }
[01:28:08.018]                           else {
[01:28:08.018]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.018]                               info, version)
[01:28:08.018]                           }
[01:28:08.018]                           base::stop(msg)
[01:28:08.018]                         }
[01:28:08.018]                       })
[01:28:08.018]                     }
[01:28:08.018]                     base::local({
[01:28:08.018]                       for (pkg in "future") {
[01:28:08.018]                         base::loadNamespace(pkg)
[01:28:08.018]                         base::library(pkg, character.only = TRUE)
[01:28:08.018]                       }
[01:28:08.018]                     })
[01:28:08.018]                   }
[01:28:08.018]                   options(future.plan = NULL)
[01:28:08.018]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.018]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.018]                 }
[01:28:08.018]                 ...future.workdir <- getwd()
[01:28:08.018]             }
[01:28:08.018]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.018]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.018]         }
[01:28:08.018]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.018]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:08.018]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.018]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.018]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.018]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.018]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.018]             base::names(...future.oldOptions))
[01:28:08.018]     }
[01:28:08.018]     if (FALSE) {
[01:28:08.018]     }
[01:28:08.018]     else {
[01:28:08.018]         if (TRUE) {
[01:28:08.018]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.018]                 open = "w")
[01:28:08.018]         }
[01:28:08.018]         else {
[01:28:08.018]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.018]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.018]         }
[01:28:08.018]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.018]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.018]             base::sink(type = "output", split = FALSE)
[01:28:08.018]             base::close(...future.stdout)
[01:28:08.018]         }, add = TRUE)
[01:28:08.018]     }
[01:28:08.018]     ...future.frame <- base::sys.nframe()
[01:28:08.018]     ...future.conditions <- base::list()
[01:28:08.018]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.018]     if (FALSE) {
[01:28:08.018]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.018]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.018]     }
[01:28:08.018]     ...future.result <- base::tryCatch({
[01:28:08.018]         base::withCallingHandlers({
[01:28:08.018]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.018]                 1))
[01:28:08.018]             future::FutureResult(value = ...future.value$value, 
[01:28:08.018]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.018]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.018]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.018]                     ...future.globalenv.names))
[01:28:08.018]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.018]         }, condition = base::local({
[01:28:08.018]             c <- base::c
[01:28:08.018]             inherits <- base::inherits
[01:28:08.018]             invokeRestart <- base::invokeRestart
[01:28:08.018]             length <- base::length
[01:28:08.018]             list <- base::list
[01:28:08.018]             seq.int <- base::seq.int
[01:28:08.018]             signalCondition <- base::signalCondition
[01:28:08.018]             sys.calls <- base::sys.calls
[01:28:08.018]             `[[` <- base::`[[`
[01:28:08.018]             `+` <- base::`+`
[01:28:08.018]             `<<-` <- base::`<<-`
[01:28:08.018]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.018]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.018]                   3L)]
[01:28:08.018]             }
[01:28:08.018]             function(cond) {
[01:28:08.018]                 is_error <- inherits(cond, "error")
[01:28:08.018]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.018]                   NULL)
[01:28:08.018]                 if (is_error) {
[01:28:08.018]                   sessionInformation <- function() {
[01:28:08.018]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.018]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.018]                       search = base::search(), system = base::Sys.info())
[01:28:08.018]                   }
[01:28:08.018]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.018]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.018]                     cond$call), session = sessionInformation(), 
[01:28:08.018]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.018]                   signalCondition(cond)
[01:28:08.018]                 }
[01:28:08.018]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.018]                 "immediateCondition"))) {
[01:28:08.018]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.018]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.018]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.018]                   if (TRUE && !signal) {
[01:28:08.018]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.018]                     {
[01:28:08.018]                       inherits <- base::inherits
[01:28:08.018]                       invokeRestart <- base::invokeRestart
[01:28:08.018]                       is.null <- base::is.null
[01:28:08.018]                       muffled <- FALSE
[01:28:08.018]                       if (inherits(cond, "message")) {
[01:28:08.018]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.018]                         if (muffled) 
[01:28:08.018]                           invokeRestart("muffleMessage")
[01:28:08.018]                       }
[01:28:08.018]                       else if (inherits(cond, "warning")) {
[01:28:08.018]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.018]                         if (muffled) 
[01:28:08.018]                           invokeRestart("muffleWarning")
[01:28:08.018]                       }
[01:28:08.018]                       else if (inherits(cond, "condition")) {
[01:28:08.018]                         if (!is.null(pattern)) {
[01:28:08.018]                           computeRestarts <- base::computeRestarts
[01:28:08.018]                           grepl <- base::grepl
[01:28:08.018]                           restarts <- computeRestarts(cond)
[01:28:08.018]                           for (restart in restarts) {
[01:28:08.018]                             name <- restart$name
[01:28:08.018]                             if (is.null(name)) 
[01:28:08.018]                               next
[01:28:08.018]                             if (!grepl(pattern, name)) 
[01:28:08.018]                               next
[01:28:08.018]                             invokeRestart(restart)
[01:28:08.018]                             muffled <- TRUE
[01:28:08.018]                             break
[01:28:08.018]                           }
[01:28:08.018]                         }
[01:28:08.018]                       }
[01:28:08.018]                       invisible(muffled)
[01:28:08.018]                     }
[01:28:08.018]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.018]                   }
[01:28:08.018]                 }
[01:28:08.018]                 else {
[01:28:08.018]                   if (TRUE) {
[01:28:08.018]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.018]                     {
[01:28:08.018]                       inherits <- base::inherits
[01:28:08.018]                       invokeRestart <- base::invokeRestart
[01:28:08.018]                       is.null <- base::is.null
[01:28:08.018]                       muffled <- FALSE
[01:28:08.018]                       if (inherits(cond, "message")) {
[01:28:08.018]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.018]                         if (muffled) 
[01:28:08.018]                           invokeRestart("muffleMessage")
[01:28:08.018]                       }
[01:28:08.018]                       else if (inherits(cond, "warning")) {
[01:28:08.018]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.018]                         if (muffled) 
[01:28:08.018]                           invokeRestart("muffleWarning")
[01:28:08.018]                       }
[01:28:08.018]                       else if (inherits(cond, "condition")) {
[01:28:08.018]                         if (!is.null(pattern)) {
[01:28:08.018]                           computeRestarts <- base::computeRestarts
[01:28:08.018]                           grepl <- base::grepl
[01:28:08.018]                           restarts <- computeRestarts(cond)
[01:28:08.018]                           for (restart in restarts) {
[01:28:08.018]                             name <- restart$name
[01:28:08.018]                             if (is.null(name)) 
[01:28:08.018]                               next
[01:28:08.018]                             if (!grepl(pattern, name)) 
[01:28:08.018]                               next
[01:28:08.018]                             invokeRestart(restart)
[01:28:08.018]                             muffled <- TRUE
[01:28:08.018]                             break
[01:28:08.018]                           }
[01:28:08.018]                         }
[01:28:08.018]                       }
[01:28:08.018]                       invisible(muffled)
[01:28:08.018]                     }
[01:28:08.018]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.018]                   }
[01:28:08.018]                 }
[01:28:08.018]             }
[01:28:08.018]         }))
[01:28:08.018]     }, error = function(ex) {
[01:28:08.018]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.018]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.018]                 ...future.rng), started = ...future.startTime, 
[01:28:08.018]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.018]             version = "1.8"), class = "FutureResult")
[01:28:08.018]     }, finally = {
[01:28:08.018]         if (!identical(...future.workdir, getwd())) 
[01:28:08.018]             setwd(...future.workdir)
[01:28:08.018]         {
[01:28:08.018]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.018]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.018]             }
[01:28:08.018]             base::options(...future.oldOptions)
[01:28:08.018]             if (.Platform$OS.type == "windows") {
[01:28:08.018]                 old_names <- names(...future.oldEnvVars)
[01:28:08.018]                 envs <- base::Sys.getenv()
[01:28:08.018]                 names <- names(envs)
[01:28:08.018]                 common <- intersect(names, old_names)
[01:28:08.018]                 added <- setdiff(names, old_names)
[01:28:08.018]                 removed <- setdiff(old_names, names)
[01:28:08.018]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.018]                   envs[common]]
[01:28:08.018]                 NAMES <- toupper(changed)
[01:28:08.018]                 args <- list()
[01:28:08.018]                 for (kk in seq_along(NAMES)) {
[01:28:08.018]                   name <- changed[[kk]]
[01:28:08.018]                   NAME <- NAMES[[kk]]
[01:28:08.018]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.018]                     next
[01:28:08.018]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.018]                 }
[01:28:08.018]                 NAMES <- toupper(added)
[01:28:08.018]                 for (kk in seq_along(NAMES)) {
[01:28:08.018]                   name <- added[[kk]]
[01:28:08.018]                   NAME <- NAMES[[kk]]
[01:28:08.018]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.018]                     next
[01:28:08.018]                   args[[name]] <- ""
[01:28:08.018]                 }
[01:28:08.018]                 NAMES <- toupper(removed)
[01:28:08.018]                 for (kk in seq_along(NAMES)) {
[01:28:08.018]                   name <- removed[[kk]]
[01:28:08.018]                   NAME <- NAMES[[kk]]
[01:28:08.018]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.018]                     next
[01:28:08.018]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.018]                 }
[01:28:08.018]                 if (length(args) > 0) 
[01:28:08.018]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.018]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.018]             }
[01:28:08.018]             else {
[01:28:08.018]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.018]             }
[01:28:08.018]             {
[01:28:08.018]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.018]                   0L) {
[01:28:08.018]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.018]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.018]                   base::options(opts)
[01:28:08.018]                 }
[01:28:08.018]                 {
[01:28:08.018]                   {
[01:28:08.018]                     NULL
[01:28:08.018]                     RNGkind("Mersenne-Twister")
[01:28:08.018]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.018]                       inherits = FALSE)
[01:28:08.018]                   }
[01:28:08.018]                   options(future.plan = NULL)
[01:28:08.018]                   if (is.na(NA_character_)) 
[01:28:08.018]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.018]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.018]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.018]                   {
[01:28:08.018]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.018]                     if (!future$lazy) 
[01:28:08.018]                       future <- run(future)
[01:28:08.018]                     invisible(future)
[01:28:08.018]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.018]                 }
[01:28:08.018]             }
[01:28:08.018]         }
[01:28:08.018]     })
[01:28:08.018]     if (TRUE) {
[01:28:08.018]         base::sink(type = "output", split = FALSE)
[01:28:08.018]         if (TRUE) {
[01:28:08.018]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.018]         }
[01:28:08.018]         else {
[01:28:08.018]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.018]         }
[01:28:08.018]         base::close(...future.stdout)
[01:28:08.018]         ...future.stdout <- NULL
[01:28:08.018]     }
[01:28:08.018]     ...future.result$conditions <- ...future.conditions
[01:28:08.018]     ...future.result$finished <- base::Sys.time()
[01:28:08.018]     ...future.result
[01:28:08.018] }
[01:28:08.021] assign_globals() ...
[01:28:08.022] List of 1
[01:28:08.022]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d88604c0> 
[01:28:08.022]  - attr(*, "where")=List of 1
[01:28:08.022]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.022]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.022]  - attr(*, "resolved")= logi TRUE
[01:28:08.022]  - attr(*, "total_size")= num 10184
[01:28:08.022]  - attr(*, "already-done")= logi TRUE
[01:28:08.025] - copied 'a' to environment
[01:28:08.025] assign_globals() ... done
[01:28:08.025] plan(): Setting new future strategy stack:
[01:28:08.026] List of future strategies:
[01:28:08.026] 1. sequential:
[01:28:08.026]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.026]    - tweaked: FALSE
[01:28:08.026]    - call: NULL
[01:28:08.026] plan(): nbrOfWorkers() = 1
[01:28:08.027] plan(): Setting new future strategy stack:
[01:28:08.028] List of future strategies:
[01:28:08.028] 1. sequential:
[01:28:08.028]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.028]    - tweaked: FALSE
[01:28:08.028]    - call: plan(strategy)
[01:28:08.028] plan(): nbrOfWorkers() = 1
[01:28:08.029] SequentialFuture started (and completed)
[01:28:08.029] - Launch lazy future ... done
[01:28:08.029] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.029] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.030] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:08.030] 
[01:28:08.031] Searching for globals ... DONE
[01:28:08.031] - globals: [0] <none>
[01:28:08.031] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.031] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.032] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:08.033] - globals found: [3] '+', 'value', 'a'
[01:28:08.033] Searching for globals ... DONE
[01:28:08.033] Resolving globals: TRUE
[01:28:08.033] Resolving any globals that are futures ...
[01:28:08.034] - globals: [3] '+', 'value', 'a'
[01:28:08.035] Resolving any globals that are futures ... DONE
[01:28:08.036] Resolving futures part of globals (recursively) ...
[01:28:08.036] resolve() on list ...
[01:28:08.036]  recursive: 99
[01:28:08.036]  length: 1
[01:28:08.036]  elements: 'a'
[01:28:08.037] run() for 'Future' ...
[01:28:08.037] - state: 'created'
[01:28:08.037] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.037] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.038] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.038]   - Field: 'label'
[01:28:08.038]   - Field: 'local'
[01:28:08.038]   - Field: 'owner'
[01:28:08.038]   - Field: 'envir'
[01:28:08.038]   - Field: 'packages'
[01:28:08.039]   - Field: 'gc'
[01:28:08.039]   - Field: 'conditions'
[01:28:08.039]   - Field: 'expr'
[01:28:08.039]   - Field: 'uuid'
[01:28:08.039]   - Field: 'seed'
[01:28:08.039]   - Field: 'version'
[01:28:08.040]   - Field: 'result'
[01:28:08.040]   - Field: 'asynchronous'
[01:28:08.040]   - Field: 'calls'
[01:28:08.040]   - Field: 'globals'
[01:28:08.040]   - Field: 'stdout'
[01:28:08.041]   - Field: 'earlySignal'
[01:28:08.041]   - Field: 'lazy'
[01:28:08.041]   - Field: 'state'
[01:28:08.041] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.041] - Launch lazy future ...
[01:28:08.042] Packages needed by the future expression (n = 0): <none>
[01:28:08.042] Packages needed by future strategies (n = 0): <none>
[01:28:08.042] {
[01:28:08.042]     {
[01:28:08.042]         {
[01:28:08.042]             ...future.startTime <- base::Sys.time()
[01:28:08.042]             {
[01:28:08.042]                 {
[01:28:08.042]                   {
[01:28:08.042]                     base::local({
[01:28:08.042]                       has_future <- base::requireNamespace("future", 
[01:28:08.042]                         quietly = TRUE)
[01:28:08.042]                       if (has_future) {
[01:28:08.042]                         ns <- base::getNamespace("future")
[01:28:08.042]                         version <- ns[[".package"]][["version"]]
[01:28:08.042]                         if (is.null(version)) 
[01:28:08.042]                           version <- utils::packageVersion("future")
[01:28:08.042]                       }
[01:28:08.042]                       else {
[01:28:08.042]                         version <- NULL
[01:28:08.042]                       }
[01:28:08.042]                       if (!has_future || version < "1.8.0") {
[01:28:08.042]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.042]                           "", base::R.version$version.string), 
[01:28:08.042]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.042]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.042]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.042]                             "release", "version")], collapse = " "), 
[01:28:08.042]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.042]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.042]                           info)
[01:28:08.042]                         info <- base::paste(info, collapse = "; ")
[01:28:08.042]                         if (!has_future) {
[01:28:08.042]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.042]                             info)
[01:28:08.042]                         }
[01:28:08.042]                         else {
[01:28:08.042]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.042]                             info, version)
[01:28:08.042]                         }
[01:28:08.042]                         base::stop(msg)
[01:28:08.042]                       }
[01:28:08.042]                     })
[01:28:08.042]                   }
[01:28:08.042]                   options(future.plan = NULL)
[01:28:08.042]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.042]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.042]                 }
[01:28:08.042]                 ...future.workdir <- getwd()
[01:28:08.042]             }
[01:28:08.042]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.042]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.042]         }
[01:28:08.042]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.042]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:08.042]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.042]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.042]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.042]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.042]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.042]             base::names(...future.oldOptions))
[01:28:08.042]     }
[01:28:08.042]     if (FALSE) {
[01:28:08.042]     }
[01:28:08.042]     else {
[01:28:08.042]         if (TRUE) {
[01:28:08.042]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.042]                 open = "w")
[01:28:08.042]         }
[01:28:08.042]         else {
[01:28:08.042]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.042]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.042]         }
[01:28:08.042]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.042]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.042]             base::sink(type = "output", split = FALSE)
[01:28:08.042]             base::close(...future.stdout)
[01:28:08.042]         }, add = TRUE)
[01:28:08.042]     }
[01:28:08.042]     ...future.frame <- base::sys.nframe()
[01:28:08.042]     ...future.conditions <- base::list()
[01:28:08.042]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.042]     if (FALSE) {
[01:28:08.042]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.042]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.042]     }
[01:28:08.042]     ...future.result <- base::tryCatch({
[01:28:08.042]         base::withCallingHandlers({
[01:28:08.042]             ...future.value <- base::withVisible(base::local(1))
[01:28:08.042]             future::FutureResult(value = ...future.value$value, 
[01:28:08.042]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.042]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.042]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.042]                     ...future.globalenv.names))
[01:28:08.042]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.042]         }, condition = base::local({
[01:28:08.042]             c <- base::c
[01:28:08.042]             inherits <- base::inherits
[01:28:08.042]             invokeRestart <- base::invokeRestart
[01:28:08.042]             length <- base::length
[01:28:08.042]             list <- base::list
[01:28:08.042]             seq.int <- base::seq.int
[01:28:08.042]             signalCondition <- base::signalCondition
[01:28:08.042]             sys.calls <- base::sys.calls
[01:28:08.042]             `[[` <- base::`[[`
[01:28:08.042]             `+` <- base::`+`
[01:28:08.042]             `<<-` <- base::`<<-`
[01:28:08.042]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.042]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.042]                   3L)]
[01:28:08.042]             }
[01:28:08.042]             function(cond) {
[01:28:08.042]                 is_error <- inherits(cond, "error")
[01:28:08.042]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.042]                   NULL)
[01:28:08.042]                 if (is_error) {
[01:28:08.042]                   sessionInformation <- function() {
[01:28:08.042]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.042]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.042]                       search = base::search(), system = base::Sys.info())
[01:28:08.042]                   }
[01:28:08.042]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.042]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.042]                     cond$call), session = sessionInformation(), 
[01:28:08.042]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.042]                   signalCondition(cond)
[01:28:08.042]                 }
[01:28:08.042]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.042]                 "immediateCondition"))) {
[01:28:08.042]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.042]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.042]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.042]                   if (TRUE && !signal) {
[01:28:08.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.042]                     {
[01:28:08.042]                       inherits <- base::inherits
[01:28:08.042]                       invokeRestart <- base::invokeRestart
[01:28:08.042]                       is.null <- base::is.null
[01:28:08.042]                       muffled <- FALSE
[01:28:08.042]                       if (inherits(cond, "message")) {
[01:28:08.042]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.042]                         if (muffled) 
[01:28:08.042]                           invokeRestart("muffleMessage")
[01:28:08.042]                       }
[01:28:08.042]                       else if (inherits(cond, "warning")) {
[01:28:08.042]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.042]                         if (muffled) 
[01:28:08.042]                           invokeRestart("muffleWarning")
[01:28:08.042]                       }
[01:28:08.042]                       else if (inherits(cond, "condition")) {
[01:28:08.042]                         if (!is.null(pattern)) {
[01:28:08.042]                           computeRestarts <- base::computeRestarts
[01:28:08.042]                           grepl <- base::grepl
[01:28:08.042]                           restarts <- computeRestarts(cond)
[01:28:08.042]                           for (restart in restarts) {
[01:28:08.042]                             name <- restart$name
[01:28:08.042]                             if (is.null(name)) 
[01:28:08.042]                               next
[01:28:08.042]                             if (!grepl(pattern, name)) 
[01:28:08.042]                               next
[01:28:08.042]                             invokeRestart(restart)
[01:28:08.042]                             muffled <- TRUE
[01:28:08.042]                             break
[01:28:08.042]                           }
[01:28:08.042]                         }
[01:28:08.042]                       }
[01:28:08.042]                       invisible(muffled)
[01:28:08.042]                     }
[01:28:08.042]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.042]                   }
[01:28:08.042]                 }
[01:28:08.042]                 else {
[01:28:08.042]                   if (TRUE) {
[01:28:08.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.042]                     {
[01:28:08.042]                       inherits <- base::inherits
[01:28:08.042]                       invokeRestart <- base::invokeRestart
[01:28:08.042]                       is.null <- base::is.null
[01:28:08.042]                       muffled <- FALSE
[01:28:08.042]                       if (inherits(cond, "message")) {
[01:28:08.042]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.042]                         if (muffled) 
[01:28:08.042]                           invokeRestart("muffleMessage")
[01:28:08.042]                       }
[01:28:08.042]                       else if (inherits(cond, "warning")) {
[01:28:08.042]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.042]                         if (muffled) 
[01:28:08.042]                           invokeRestart("muffleWarning")
[01:28:08.042]                       }
[01:28:08.042]                       else if (inherits(cond, "condition")) {
[01:28:08.042]                         if (!is.null(pattern)) {
[01:28:08.042]                           computeRestarts <- base::computeRestarts
[01:28:08.042]                           grepl <- base::grepl
[01:28:08.042]                           restarts <- computeRestarts(cond)
[01:28:08.042]                           for (restart in restarts) {
[01:28:08.042]                             name <- restart$name
[01:28:08.042]                             if (is.null(name)) 
[01:28:08.042]                               next
[01:28:08.042]                             if (!grepl(pattern, name)) 
[01:28:08.042]                               next
[01:28:08.042]                             invokeRestart(restart)
[01:28:08.042]                             muffled <- TRUE
[01:28:08.042]                             break
[01:28:08.042]                           }
[01:28:08.042]                         }
[01:28:08.042]                       }
[01:28:08.042]                       invisible(muffled)
[01:28:08.042]                     }
[01:28:08.042]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.042]                   }
[01:28:08.042]                 }
[01:28:08.042]             }
[01:28:08.042]         }))
[01:28:08.042]     }, error = function(ex) {
[01:28:08.042]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.042]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.042]                 ...future.rng), started = ...future.startTime, 
[01:28:08.042]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.042]             version = "1.8"), class = "FutureResult")
[01:28:08.042]     }, finally = {
[01:28:08.042]         if (!identical(...future.workdir, getwd())) 
[01:28:08.042]             setwd(...future.workdir)
[01:28:08.042]         {
[01:28:08.042]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.042]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.042]             }
[01:28:08.042]             base::options(...future.oldOptions)
[01:28:08.042]             if (.Platform$OS.type == "windows") {
[01:28:08.042]                 old_names <- names(...future.oldEnvVars)
[01:28:08.042]                 envs <- base::Sys.getenv()
[01:28:08.042]                 names <- names(envs)
[01:28:08.042]                 common <- intersect(names, old_names)
[01:28:08.042]                 added <- setdiff(names, old_names)
[01:28:08.042]                 removed <- setdiff(old_names, names)
[01:28:08.042]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.042]                   envs[common]]
[01:28:08.042]                 NAMES <- toupper(changed)
[01:28:08.042]                 args <- list()
[01:28:08.042]                 for (kk in seq_along(NAMES)) {
[01:28:08.042]                   name <- changed[[kk]]
[01:28:08.042]                   NAME <- NAMES[[kk]]
[01:28:08.042]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.042]                     next
[01:28:08.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.042]                 }
[01:28:08.042]                 NAMES <- toupper(added)
[01:28:08.042]                 for (kk in seq_along(NAMES)) {
[01:28:08.042]                   name <- added[[kk]]
[01:28:08.042]                   NAME <- NAMES[[kk]]
[01:28:08.042]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.042]                     next
[01:28:08.042]                   args[[name]] <- ""
[01:28:08.042]                 }
[01:28:08.042]                 NAMES <- toupper(removed)
[01:28:08.042]                 for (kk in seq_along(NAMES)) {
[01:28:08.042]                   name <- removed[[kk]]
[01:28:08.042]                   NAME <- NAMES[[kk]]
[01:28:08.042]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.042]                     next
[01:28:08.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.042]                 }
[01:28:08.042]                 if (length(args) > 0) 
[01:28:08.042]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.042]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.042]             }
[01:28:08.042]             else {
[01:28:08.042]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.042]             }
[01:28:08.042]             {
[01:28:08.042]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.042]                   0L) {
[01:28:08.042]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.042]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.042]                   base::options(opts)
[01:28:08.042]                 }
[01:28:08.042]                 {
[01:28:08.042]                   {
[01:28:08.042]                     NULL
[01:28:08.042]                     RNGkind("Mersenne-Twister")
[01:28:08.042]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.042]                       inherits = FALSE)
[01:28:08.042]                   }
[01:28:08.042]                   options(future.plan = NULL)
[01:28:08.042]                   if (is.na(NA_character_)) 
[01:28:08.042]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.042]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.042]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.042]                   {
[01:28:08.042]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.042]                     if (!future$lazy) 
[01:28:08.042]                       future <- run(future)
[01:28:08.042]                     invisible(future)
[01:28:08.042]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.042]                 }
[01:28:08.042]             }
[01:28:08.042]         }
[01:28:08.042]     })
[01:28:08.042]     if (TRUE) {
[01:28:08.042]         base::sink(type = "output", split = FALSE)
[01:28:08.042]         if (TRUE) {
[01:28:08.042]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.042]         }
[01:28:08.042]         else {
[01:28:08.042]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.042]         }
[01:28:08.042]         base::close(...future.stdout)
[01:28:08.042]         ...future.stdout <- NULL
[01:28:08.042]     }
[01:28:08.042]     ...future.result$conditions <- ...future.conditions
[01:28:08.042]     ...future.result$finished <- base::Sys.time()
[01:28:08.042]     ...future.result
[01:28:08.042] }
[01:28:08.046] plan(): Setting new future strategy stack:
[01:28:08.046] List of future strategies:
[01:28:08.046] 1. sequential:
[01:28:08.046]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.046]    - tweaked: FALSE
[01:28:08.046]    - call: NULL
[01:28:08.047] plan(): nbrOfWorkers() = 1
[01:28:08.048] plan(): Setting new future strategy stack:
[01:28:08.048] List of future strategies:
[01:28:08.048] 1. sequential:
[01:28:08.048]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.048]    - tweaked: FALSE
[01:28:08.048]    - call: plan(strategy)
[01:28:08.049] plan(): nbrOfWorkers() = 1
[01:28:08.049] SequentialFuture started (and completed)
[01:28:08.049] - Launch lazy future ... done
[01:28:08.050] run() for 'SequentialFuture' ... done
[01:28:08.050] resolved() for 'SequentialFuture' ...
[01:28:08.050] - state: 'finished'
[01:28:08.050] - run: TRUE
[01:28:08.051] - result: 'FutureResult'
[01:28:08.051] resolved() for 'SequentialFuture' ... done
[01:28:08.051] Future #1
[01:28:08.051] resolved() for 'SequentialFuture' ...
[01:28:08.051] - state: 'finished'
[01:28:08.052] - run: TRUE
[01:28:08.052] - result: 'FutureResult'
[01:28:08.052] resolved() for 'SequentialFuture' ... done
[01:28:08.052] A SequentialFuture was resolved
[01:28:08.052]  length: 0 (resolved future 1)
[01:28:08.052] resolve() on list ... DONE
[01:28:08.053] - globals: [1] 'a'
[01:28:08.053] Resolving futures part of globals (recursively) ... DONE
[01:28:08.054] The total size of the 1 globals is 10.11 KiB (10352 bytes)
[01:28:08.054] The total size of the 1 globals exported for future expression ('value(a) + 1') is 10.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (10.11 KiB of class 'environment')
[01:28:08.054] - globals: [1] 'a'
[01:28:08.055] - packages: [1] 'future'
[01:28:08.055] getGlobalsAndPackages() ... DONE
[01:28:08.055] run() for 'Future' ...
[01:28:08.055] - state: 'created'
[01:28:08.056] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.056] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.056] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.056]   - Field: 'label'
[01:28:08.057]   - Field: 'local'
[01:28:08.057]   - Field: 'owner'
[01:28:08.057]   - Field: 'envir'
[01:28:08.057]   - Field: 'packages'
[01:28:08.058]   - Field: 'gc'
[01:28:08.058]   - Field: 'conditions'
[01:28:08.058]   - Field: 'expr'
[01:28:08.058]   - Field: 'uuid'
[01:28:08.058]   - Field: 'seed'
[01:28:08.058]   - Field: 'version'
[01:28:08.059]   - Field: 'result'
[01:28:08.059]   - Field: 'asynchronous'
[01:28:08.059]   - Field: 'calls'
[01:28:08.059]   - Field: 'globals'
[01:28:08.059]   - Field: 'stdout'
[01:28:08.060]   - Field: 'earlySignal'
[01:28:08.060]   - Field: 'lazy'
[01:28:08.060]   - Field: 'state'
[01:28:08.060] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.060] - Launch lazy future ...
[01:28:08.061] Packages needed by the future expression (n = 1): 'future'
[01:28:08.061] Packages needed by future strategies (n = 0): <none>
[01:28:08.061] {
[01:28:08.061]     {
[01:28:08.061]         {
[01:28:08.061]             ...future.startTime <- base::Sys.time()
[01:28:08.061]             {
[01:28:08.061]                 {
[01:28:08.061]                   {
[01:28:08.061]                     {
[01:28:08.061]                       base::local({
[01:28:08.061]                         has_future <- base::requireNamespace("future", 
[01:28:08.061]                           quietly = TRUE)
[01:28:08.061]                         if (has_future) {
[01:28:08.061]                           ns <- base::getNamespace("future")
[01:28:08.061]                           version <- ns[[".package"]][["version"]]
[01:28:08.061]                           if (is.null(version)) 
[01:28:08.061]                             version <- utils::packageVersion("future")
[01:28:08.061]                         }
[01:28:08.061]                         else {
[01:28:08.061]                           version <- NULL
[01:28:08.061]                         }
[01:28:08.061]                         if (!has_future || version < "1.8.0") {
[01:28:08.061]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.061]                             "", base::R.version$version.string), 
[01:28:08.061]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.061]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.061]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.061]                               "release", "version")], collapse = " "), 
[01:28:08.061]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.061]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.061]                             info)
[01:28:08.061]                           info <- base::paste(info, collapse = "; ")
[01:28:08.061]                           if (!has_future) {
[01:28:08.061]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.061]                               info)
[01:28:08.061]                           }
[01:28:08.061]                           else {
[01:28:08.061]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.061]                               info, version)
[01:28:08.061]                           }
[01:28:08.061]                           base::stop(msg)
[01:28:08.061]                         }
[01:28:08.061]                       })
[01:28:08.061]                     }
[01:28:08.061]                     base::local({
[01:28:08.061]                       for (pkg in "future") {
[01:28:08.061]                         base::loadNamespace(pkg)
[01:28:08.061]                         base::library(pkg, character.only = TRUE)
[01:28:08.061]                       }
[01:28:08.061]                     })
[01:28:08.061]                   }
[01:28:08.061]                   options(future.plan = NULL)
[01:28:08.061]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.061]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.061]                 }
[01:28:08.061]                 ...future.workdir <- getwd()
[01:28:08.061]             }
[01:28:08.061]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.061]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.061]         }
[01:28:08.061]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.061]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:08.061]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.061]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.061]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.061]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.061]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.061]             base::names(...future.oldOptions))
[01:28:08.061]     }
[01:28:08.061]     if (FALSE) {
[01:28:08.061]     }
[01:28:08.061]     else {
[01:28:08.061]         if (TRUE) {
[01:28:08.061]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.061]                 open = "w")
[01:28:08.061]         }
[01:28:08.061]         else {
[01:28:08.061]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.061]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.061]         }
[01:28:08.061]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.061]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.061]             base::sink(type = "output", split = FALSE)
[01:28:08.061]             base::close(...future.stdout)
[01:28:08.061]         }, add = TRUE)
[01:28:08.061]     }
[01:28:08.061]     ...future.frame <- base::sys.nframe()
[01:28:08.061]     ...future.conditions <- base::list()
[01:28:08.061]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.061]     if (FALSE) {
[01:28:08.061]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.061]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.061]     }
[01:28:08.061]     ...future.result <- base::tryCatch({
[01:28:08.061]         base::withCallingHandlers({
[01:28:08.061]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.061]                 1))
[01:28:08.061]             future::FutureResult(value = ...future.value$value, 
[01:28:08.061]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.061]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.061]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.061]                     ...future.globalenv.names))
[01:28:08.061]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.061]         }, condition = base::local({
[01:28:08.061]             c <- base::c
[01:28:08.061]             inherits <- base::inherits
[01:28:08.061]             invokeRestart <- base::invokeRestart
[01:28:08.061]             length <- base::length
[01:28:08.061]             list <- base::list
[01:28:08.061]             seq.int <- base::seq.int
[01:28:08.061]             signalCondition <- base::signalCondition
[01:28:08.061]             sys.calls <- base::sys.calls
[01:28:08.061]             `[[` <- base::`[[`
[01:28:08.061]             `+` <- base::`+`
[01:28:08.061]             `<<-` <- base::`<<-`
[01:28:08.061]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.061]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.061]                   3L)]
[01:28:08.061]             }
[01:28:08.061]             function(cond) {
[01:28:08.061]                 is_error <- inherits(cond, "error")
[01:28:08.061]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.061]                   NULL)
[01:28:08.061]                 if (is_error) {
[01:28:08.061]                   sessionInformation <- function() {
[01:28:08.061]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.061]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.061]                       search = base::search(), system = base::Sys.info())
[01:28:08.061]                   }
[01:28:08.061]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.061]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.061]                     cond$call), session = sessionInformation(), 
[01:28:08.061]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.061]                   signalCondition(cond)
[01:28:08.061]                 }
[01:28:08.061]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.061]                 "immediateCondition"))) {
[01:28:08.061]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.061]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.061]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.061]                   if (TRUE && !signal) {
[01:28:08.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.061]                     {
[01:28:08.061]                       inherits <- base::inherits
[01:28:08.061]                       invokeRestart <- base::invokeRestart
[01:28:08.061]                       is.null <- base::is.null
[01:28:08.061]                       muffled <- FALSE
[01:28:08.061]                       if (inherits(cond, "message")) {
[01:28:08.061]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.061]                         if (muffled) 
[01:28:08.061]                           invokeRestart("muffleMessage")
[01:28:08.061]                       }
[01:28:08.061]                       else if (inherits(cond, "warning")) {
[01:28:08.061]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.061]                         if (muffled) 
[01:28:08.061]                           invokeRestart("muffleWarning")
[01:28:08.061]                       }
[01:28:08.061]                       else if (inherits(cond, "condition")) {
[01:28:08.061]                         if (!is.null(pattern)) {
[01:28:08.061]                           computeRestarts <- base::computeRestarts
[01:28:08.061]                           grepl <- base::grepl
[01:28:08.061]                           restarts <- computeRestarts(cond)
[01:28:08.061]                           for (restart in restarts) {
[01:28:08.061]                             name <- restart$name
[01:28:08.061]                             if (is.null(name)) 
[01:28:08.061]                               next
[01:28:08.061]                             if (!grepl(pattern, name)) 
[01:28:08.061]                               next
[01:28:08.061]                             invokeRestart(restart)
[01:28:08.061]                             muffled <- TRUE
[01:28:08.061]                             break
[01:28:08.061]                           }
[01:28:08.061]                         }
[01:28:08.061]                       }
[01:28:08.061]                       invisible(muffled)
[01:28:08.061]                     }
[01:28:08.061]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.061]                   }
[01:28:08.061]                 }
[01:28:08.061]                 else {
[01:28:08.061]                   if (TRUE) {
[01:28:08.061]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.061]                     {
[01:28:08.061]                       inherits <- base::inherits
[01:28:08.061]                       invokeRestart <- base::invokeRestart
[01:28:08.061]                       is.null <- base::is.null
[01:28:08.061]                       muffled <- FALSE
[01:28:08.061]                       if (inherits(cond, "message")) {
[01:28:08.061]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.061]                         if (muffled) 
[01:28:08.061]                           invokeRestart("muffleMessage")
[01:28:08.061]                       }
[01:28:08.061]                       else if (inherits(cond, "warning")) {
[01:28:08.061]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.061]                         if (muffled) 
[01:28:08.061]                           invokeRestart("muffleWarning")
[01:28:08.061]                       }
[01:28:08.061]                       else if (inherits(cond, "condition")) {
[01:28:08.061]                         if (!is.null(pattern)) {
[01:28:08.061]                           computeRestarts <- base::computeRestarts
[01:28:08.061]                           grepl <- base::grepl
[01:28:08.061]                           restarts <- computeRestarts(cond)
[01:28:08.061]                           for (restart in restarts) {
[01:28:08.061]                             name <- restart$name
[01:28:08.061]                             if (is.null(name)) 
[01:28:08.061]                               next
[01:28:08.061]                             if (!grepl(pattern, name)) 
[01:28:08.061]                               next
[01:28:08.061]                             invokeRestart(restart)
[01:28:08.061]                             muffled <- TRUE
[01:28:08.061]                             break
[01:28:08.061]                           }
[01:28:08.061]                         }
[01:28:08.061]                       }
[01:28:08.061]                       invisible(muffled)
[01:28:08.061]                     }
[01:28:08.061]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.061]                   }
[01:28:08.061]                 }
[01:28:08.061]             }
[01:28:08.061]         }))
[01:28:08.061]     }, error = function(ex) {
[01:28:08.061]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.061]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.061]                 ...future.rng), started = ...future.startTime, 
[01:28:08.061]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.061]             version = "1.8"), class = "FutureResult")
[01:28:08.061]     }, finally = {
[01:28:08.061]         if (!identical(...future.workdir, getwd())) 
[01:28:08.061]             setwd(...future.workdir)
[01:28:08.061]         {
[01:28:08.061]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.061]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.061]             }
[01:28:08.061]             base::options(...future.oldOptions)
[01:28:08.061]             if (.Platform$OS.type == "windows") {
[01:28:08.061]                 old_names <- names(...future.oldEnvVars)
[01:28:08.061]                 envs <- base::Sys.getenv()
[01:28:08.061]                 names <- names(envs)
[01:28:08.061]                 common <- intersect(names, old_names)
[01:28:08.061]                 added <- setdiff(names, old_names)
[01:28:08.061]                 removed <- setdiff(old_names, names)
[01:28:08.061]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.061]                   envs[common]]
[01:28:08.061]                 NAMES <- toupper(changed)
[01:28:08.061]                 args <- list()
[01:28:08.061]                 for (kk in seq_along(NAMES)) {
[01:28:08.061]                   name <- changed[[kk]]
[01:28:08.061]                   NAME <- NAMES[[kk]]
[01:28:08.061]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.061]                     next
[01:28:08.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.061]                 }
[01:28:08.061]                 NAMES <- toupper(added)
[01:28:08.061]                 for (kk in seq_along(NAMES)) {
[01:28:08.061]                   name <- added[[kk]]
[01:28:08.061]                   NAME <- NAMES[[kk]]
[01:28:08.061]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.061]                     next
[01:28:08.061]                   args[[name]] <- ""
[01:28:08.061]                 }
[01:28:08.061]                 NAMES <- toupper(removed)
[01:28:08.061]                 for (kk in seq_along(NAMES)) {
[01:28:08.061]                   name <- removed[[kk]]
[01:28:08.061]                   NAME <- NAMES[[kk]]
[01:28:08.061]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.061]                     next
[01:28:08.061]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.061]                 }
[01:28:08.061]                 if (length(args) > 0) 
[01:28:08.061]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.061]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.061]             }
[01:28:08.061]             else {
[01:28:08.061]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.061]             }
[01:28:08.061]             {
[01:28:08.061]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.061]                   0L) {
[01:28:08.061]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.061]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.061]                   base::options(opts)
[01:28:08.061]                 }
[01:28:08.061]                 {
[01:28:08.061]                   {
[01:28:08.061]                     NULL
[01:28:08.061]                     RNGkind("Mersenne-Twister")
[01:28:08.061]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.061]                       inherits = FALSE)
[01:28:08.061]                   }
[01:28:08.061]                   options(future.plan = NULL)
[01:28:08.061]                   if (is.na(NA_character_)) 
[01:28:08.061]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.061]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.061]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.061]                   {
[01:28:08.061]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.061]                     if (!future$lazy) 
[01:28:08.061]                       future <- run(future)
[01:28:08.061]                     invisible(future)
[01:28:08.061]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.061]                 }
[01:28:08.061]             }
[01:28:08.061]         }
[01:28:08.061]     })
[01:28:08.061]     if (TRUE) {
[01:28:08.061]         base::sink(type = "output", split = FALSE)
[01:28:08.061]         if (TRUE) {
[01:28:08.061]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.061]         }
[01:28:08.061]         else {
[01:28:08.061]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.061]         }
[01:28:08.061]         base::close(...future.stdout)
[01:28:08.061]         ...future.stdout <- NULL
[01:28:08.061]     }
[01:28:08.061]     ...future.result$conditions <- ...future.conditions
[01:28:08.061]     ...future.result$finished <- base::Sys.time()
[01:28:08.061]     ...future.result
[01:28:08.061] }
[01:28:08.065] assign_globals() ...
[01:28:08.065] List of 1
[01:28:08.065]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d8b92ed8> 
[01:28:08.065]  - attr(*, "where")=List of 1
[01:28:08.065]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.065]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.065]  - attr(*, "resolved")= logi TRUE
[01:28:08.065]  - attr(*, "total_size")= num 10352
[01:28:08.065]  - attr(*, "already-done")= logi TRUE
[01:28:08.069] - copied 'a' to environment
[01:28:08.069] assign_globals() ... done
[01:28:08.069] plan(): Setting new future strategy stack:
[01:28:08.070] List of future strategies:
[01:28:08.070] 1. sequential:
[01:28:08.070]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.070]    - tweaked: FALSE
[01:28:08.070]    - call: NULL
[01:28:08.070] plan(): nbrOfWorkers() = 1
[01:28:08.072] plan(): Setting new future strategy stack:
[01:28:08.074] List of future strategies:
[01:28:08.074] 1. sequential:
[01:28:08.074]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.074]    - tweaked: FALSE
[01:28:08.074]    - call: plan(strategy)
[01:28:08.075] plan(): nbrOfWorkers() = 1
[01:28:08.075] SequentialFuture started (and completed)
[01:28:08.075] - Launch lazy future ... done
[01:28:08.075] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.076] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.076] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:08.077] 
[01:28:08.077] Searching for globals ... DONE
[01:28:08.077] - globals: [0] <none>
[01:28:08.078] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.078] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.078] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:08.080] - globals found: [3] '+', 'value', 'a'
[01:28:08.080] Searching for globals ... DONE
[01:28:08.080] Resolving globals: TRUE
[01:28:08.080] Resolving any globals that are futures ...
[01:28:08.080] - globals: [3] '+', 'value', 'a'
[01:28:08.080] Resolving any globals that are futures ... DONE
[01:28:08.081] Resolving futures part of globals (recursively) ...
[01:28:08.081] resolve() on list ...
[01:28:08.081]  recursive: 99
[01:28:08.082]  length: 1
[01:28:08.082]  elements: 'a'
[01:28:08.082] run() for 'Future' ...
[01:28:08.082] - state: 'created'
[01:28:08.082] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.083] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.083] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.083]   - Field: 'label'
[01:28:08.083]   - Field: 'local'
[01:28:08.083]   - Field: 'owner'
[01:28:08.084]   - Field: 'envir'
[01:28:08.084]   - Field: 'packages'
[01:28:08.084]   - Field: 'gc'
[01:28:08.084]   - Field: 'conditions'
[01:28:08.084]   - Field: 'expr'
[01:28:08.085]   - Field: 'uuid'
[01:28:08.085]   - Field: 'seed'
[01:28:08.085]   - Field: 'version'
[01:28:08.085]   - Field: 'result'
[01:28:08.085]   - Field: 'asynchronous'
[01:28:08.085]   - Field: 'calls'
[01:28:08.086]   - Field: 'globals'
[01:28:08.086]   - Field: 'stdout'
[01:28:08.086]   - Field: 'earlySignal'
[01:28:08.086]   - Field: 'lazy'
[01:28:08.086]   - Field: 'state'
[01:28:08.087] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.087] - Launch lazy future ...
[01:28:08.087] Packages needed by the future expression (n = 0): <none>
[01:28:08.087] Packages needed by future strategies (n = 0): <none>
[01:28:08.088] {
[01:28:08.088]     {
[01:28:08.088]         {
[01:28:08.088]             ...future.startTime <- base::Sys.time()
[01:28:08.088]             {
[01:28:08.088]                 {
[01:28:08.088]                   {
[01:28:08.088]                     base::local({
[01:28:08.088]                       has_future <- base::requireNamespace("future", 
[01:28:08.088]                         quietly = TRUE)
[01:28:08.088]                       if (has_future) {
[01:28:08.088]                         ns <- base::getNamespace("future")
[01:28:08.088]                         version <- ns[[".package"]][["version"]]
[01:28:08.088]                         if (is.null(version)) 
[01:28:08.088]                           version <- utils::packageVersion("future")
[01:28:08.088]                       }
[01:28:08.088]                       else {
[01:28:08.088]                         version <- NULL
[01:28:08.088]                       }
[01:28:08.088]                       if (!has_future || version < "1.8.0") {
[01:28:08.088]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.088]                           "", base::R.version$version.string), 
[01:28:08.088]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.088]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.088]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.088]                             "release", "version")], collapse = " "), 
[01:28:08.088]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.088]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.088]                           info)
[01:28:08.088]                         info <- base::paste(info, collapse = "; ")
[01:28:08.088]                         if (!has_future) {
[01:28:08.088]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.088]                             info)
[01:28:08.088]                         }
[01:28:08.088]                         else {
[01:28:08.088]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.088]                             info, version)
[01:28:08.088]                         }
[01:28:08.088]                         base::stop(msg)
[01:28:08.088]                       }
[01:28:08.088]                     })
[01:28:08.088]                   }
[01:28:08.088]                   options(future.plan = NULL)
[01:28:08.088]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.088]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.088]                 }
[01:28:08.088]                 ...future.workdir <- getwd()
[01:28:08.088]             }
[01:28:08.088]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.088]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.088]         }
[01:28:08.088]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.088]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:08.088]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.088]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.088]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.088]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.088]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.088]             base::names(...future.oldOptions))
[01:28:08.088]     }
[01:28:08.088]     if (FALSE) {
[01:28:08.088]     }
[01:28:08.088]     else {
[01:28:08.088]         if (TRUE) {
[01:28:08.088]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.088]                 open = "w")
[01:28:08.088]         }
[01:28:08.088]         else {
[01:28:08.088]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.088]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.088]         }
[01:28:08.088]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.088]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.088]             base::sink(type = "output", split = FALSE)
[01:28:08.088]             base::close(...future.stdout)
[01:28:08.088]         }, add = TRUE)
[01:28:08.088]     }
[01:28:08.088]     ...future.frame <- base::sys.nframe()
[01:28:08.088]     ...future.conditions <- base::list()
[01:28:08.088]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.088]     if (FALSE) {
[01:28:08.088]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.088]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.088]     }
[01:28:08.088]     ...future.result <- base::tryCatch({
[01:28:08.088]         base::withCallingHandlers({
[01:28:08.088]             ...future.value <- base::withVisible(base::local(1))
[01:28:08.088]             future::FutureResult(value = ...future.value$value, 
[01:28:08.088]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.088]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.088]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.088]                     ...future.globalenv.names))
[01:28:08.088]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.088]         }, condition = base::local({
[01:28:08.088]             c <- base::c
[01:28:08.088]             inherits <- base::inherits
[01:28:08.088]             invokeRestart <- base::invokeRestart
[01:28:08.088]             length <- base::length
[01:28:08.088]             list <- base::list
[01:28:08.088]             seq.int <- base::seq.int
[01:28:08.088]             signalCondition <- base::signalCondition
[01:28:08.088]             sys.calls <- base::sys.calls
[01:28:08.088]             `[[` <- base::`[[`
[01:28:08.088]             `+` <- base::`+`
[01:28:08.088]             `<<-` <- base::`<<-`
[01:28:08.088]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.088]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.088]                   3L)]
[01:28:08.088]             }
[01:28:08.088]             function(cond) {
[01:28:08.088]                 is_error <- inherits(cond, "error")
[01:28:08.088]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.088]                   NULL)
[01:28:08.088]                 if (is_error) {
[01:28:08.088]                   sessionInformation <- function() {
[01:28:08.088]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.088]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.088]                       search = base::search(), system = base::Sys.info())
[01:28:08.088]                   }
[01:28:08.088]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.088]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.088]                     cond$call), session = sessionInformation(), 
[01:28:08.088]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.088]                   signalCondition(cond)
[01:28:08.088]                 }
[01:28:08.088]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.088]                 "immediateCondition"))) {
[01:28:08.088]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.088]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.088]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.088]                   if (TRUE && !signal) {
[01:28:08.088]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.088]                     {
[01:28:08.088]                       inherits <- base::inherits
[01:28:08.088]                       invokeRestart <- base::invokeRestart
[01:28:08.088]                       is.null <- base::is.null
[01:28:08.088]                       muffled <- FALSE
[01:28:08.088]                       if (inherits(cond, "message")) {
[01:28:08.088]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.088]                         if (muffled) 
[01:28:08.088]                           invokeRestart("muffleMessage")
[01:28:08.088]                       }
[01:28:08.088]                       else if (inherits(cond, "warning")) {
[01:28:08.088]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.088]                         if (muffled) 
[01:28:08.088]                           invokeRestart("muffleWarning")
[01:28:08.088]                       }
[01:28:08.088]                       else if (inherits(cond, "condition")) {
[01:28:08.088]                         if (!is.null(pattern)) {
[01:28:08.088]                           computeRestarts <- base::computeRestarts
[01:28:08.088]                           grepl <- base::grepl
[01:28:08.088]                           restarts <- computeRestarts(cond)
[01:28:08.088]                           for (restart in restarts) {
[01:28:08.088]                             name <- restart$name
[01:28:08.088]                             if (is.null(name)) 
[01:28:08.088]                               next
[01:28:08.088]                             if (!grepl(pattern, name)) 
[01:28:08.088]                               next
[01:28:08.088]                             invokeRestart(restart)
[01:28:08.088]                             muffled <- TRUE
[01:28:08.088]                             break
[01:28:08.088]                           }
[01:28:08.088]                         }
[01:28:08.088]                       }
[01:28:08.088]                       invisible(muffled)
[01:28:08.088]                     }
[01:28:08.088]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.088]                   }
[01:28:08.088]                 }
[01:28:08.088]                 else {
[01:28:08.088]                   if (TRUE) {
[01:28:08.088]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.088]                     {
[01:28:08.088]                       inherits <- base::inherits
[01:28:08.088]                       invokeRestart <- base::invokeRestart
[01:28:08.088]                       is.null <- base::is.null
[01:28:08.088]                       muffled <- FALSE
[01:28:08.088]                       if (inherits(cond, "message")) {
[01:28:08.088]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.088]                         if (muffled) 
[01:28:08.088]                           invokeRestart("muffleMessage")
[01:28:08.088]                       }
[01:28:08.088]                       else if (inherits(cond, "warning")) {
[01:28:08.088]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.088]                         if (muffled) 
[01:28:08.088]                           invokeRestart("muffleWarning")
[01:28:08.088]                       }
[01:28:08.088]                       else if (inherits(cond, "condition")) {
[01:28:08.088]                         if (!is.null(pattern)) {
[01:28:08.088]                           computeRestarts <- base::computeRestarts
[01:28:08.088]                           grepl <- base::grepl
[01:28:08.088]                           restarts <- computeRestarts(cond)
[01:28:08.088]                           for (restart in restarts) {
[01:28:08.088]                             name <- restart$name
[01:28:08.088]                             if (is.null(name)) 
[01:28:08.088]                               next
[01:28:08.088]                             if (!grepl(pattern, name)) 
[01:28:08.088]                               next
[01:28:08.088]                             invokeRestart(restart)
[01:28:08.088]                             muffled <- TRUE
[01:28:08.088]                             break
[01:28:08.088]                           }
[01:28:08.088]                         }
[01:28:08.088]                       }
[01:28:08.088]                       invisible(muffled)
[01:28:08.088]                     }
[01:28:08.088]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.088]                   }
[01:28:08.088]                 }
[01:28:08.088]             }
[01:28:08.088]         }))
[01:28:08.088]     }, error = function(ex) {
[01:28:08.088]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.088]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.088]                 ...future.rng), started = ...future.startTime, 
[01:28:08.088]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.088]             version = "1.8"), class = "FutureResult")
[01:28:08.088]     }, finally = {
[01:28:08.088]         if (!identical(...future.workdir, getwd())) 
[01:28:08.088]             setwd(...future.workdir)
[01:28:08.088]         {
[01:28:08.088]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.088]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.088]             }
[01:28:08.088]             base::options(...future.oldOptions)
[01:28:08.088]             if (.Platform$OS.type == "windows") {
[01:28:08.088]                 old_names <- names(...future.oldEnvVars)
[01:28:08.088]                 envs <- base::Sys.getenv()
[01:28:08.088]                 names <- names(envs)
[01:28:08.088]                 common <- intersect(names, old_names)
[01:28:08.088]                 added <- setdiff(names, old_names)
[01:28:08.088]                 removed <- setdiff(old_names, names)
[01:28:08.088]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.088]                   envs[common]]
[01:28:08.088]                 NAMES <- toupper(changed)
[01:28:08.088]                 args <- list()
[01:28:08.088]                 for (kk in seq_along(NAMES)) {
[01:28:08.088]                   name <- changed[[kk]]
[01:28:08.088]                   NAME <- NAMES[[kk]]
[01:28:08.088]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.088]                     next
[01:28:08.088]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.088]                 }
[01:28:08.088]                 NAMES <- toupper(added)
[01:28:08.088]                 for (kk in seq_along(NAMES)) {
[01:28:08.088]                   name <- added[[kk]]
[01:28:08.088]                   NAME <- NAMES[[kk]]
[01:28:08.088]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.088]                     next
[01:28:08.088]                   args[[name]] <- ""
[01:28:08.088]                 }
[01:28:08.088]                 NAMES <- toupper(removed)
[01:28:08.088]                 for (kk in seq_along(NAMES)) {
[01:28:08.088]                   name <- removed[[kk]]
[01:28:08.088]                   NAME <- NAMES[[kk]]
[01:28:08.088]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.088]                     next
[01:28:08.088]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.088]                 }
[01:28:08.088]                 if (length(args) > 0) 
[01:28:08.088]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.088]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.088]             }
[01:28:08.088]             else {
[01:28:08.088]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.088]             }
[01:28:08.088]             {
[01:28:08.088]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.088]                   0L) {
[01:28:08.088]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.088]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.088]                   base::options(opts)
[01:28:08.088]                 }
[01:28:08.088]                 {
[01:28:08.088]                   {
[01:28:08.088]                     NULL
[01:28:08.088]                     RNGkind("Mersenne-Twister")
[01:28:08.088]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.088]                       inherits = FALSE)
[01:28:08.088]                   }
[01:28:08.088]                   options(future.plan = NULL)
[01:28:08.088]                   if (is.na(NA_character_)) 
[01:28:08.088]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.088]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.088]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.088]                   {
[01:28:08.088]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.088]                     if (!future$lazy) 
[01:28:08.088]                       future <- run(future)
[01:28:08.088]                     invisible(future)
[01:28:08.088]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.088]                 }
[01:28:08.088]             }
[01:28:08.088]         }
[01:28:08.088]     })
[01:28:08.088]     if (TRUE) {
[01:28:08.088]         base::sink(type = "output", split = FALSE)
[01:28:08.088]         if (TRUE) {
[01:28:08.088]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.088]         }
[01:28:08.088]         else {
[01:28:08.088]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.088]         }
[01:28:08.088]         base::close(...future.stdout)
[01:28:08.088]         ...future.stdout <- NULL
[01:28:08.088]     }
[01:28:08.088]     ...future.result$conditions <- ...future.conditions
[01:28:08.088]     ...future.result$finished <- base::Sys.time()
[01:28:08.088]     ...future.result
[01:28:08.088] }
[01:28:08.092] plan(): Setting new future strategy stack:
[01:28:08.092] List of future strategies:
[01:28:08.092] 1. sequential:
[01:28:08.092]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.092]    - tweaked: FALSE
[01:28:08.092]    - call: NULL
[01:28:08.093] plan(): nbrOfWorkers() = 1
[01:28:08.094] plan(): Setting new future strategy stack:
[01:28:08.094] List of future strategies:
[01:28:08.094] 1. sequential:
[01:28:08.094]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.094]    - tweaked: FALSE
[01:28:08.094]    - call: plan(strategy)
[01:28:08.094] plan(): nbrOfWorkers() = 1
[01:28:08.095] SequentialFuture started (and completed)
[01:28:08.095] - Launch lazy future ... done
[01:28:08.095] run() for 'SequentialFuture' ... done
[01:28:08.095] resolved() for 'SequentialFuture' ...
[01:28:08.096] - state: 'finished'
[01:28:08.096] - run: TRUE
[01:28:08.096] - result: 'FutureResult'
[01:28:08.096] resolved() for 'SequentialFuture' ... done
[01:28:08.096] Future #1
[01:28:08.097] resolved() for 'SequentialFuture' ...
[01:28:08.097] - state: 'finished'
[01:28:08.097] - run: TRUE
[01:28:08.097] - result: 'FutureResult'
[01:28:08.097] resolved() for 'SequentialFuture' ... done
[01:28:08.098] A SequentialFuture was resolved
[01:28:08.098]  length: 0 (resolved future 1)
[01:28:08.098] resolve() on list ... DONE
[01:28:08.098] - globals: [1] 'a'
[01:28:08.098] Resolving futures part of globals (recursively) ... DONE
[01:28:08.099] The total size of the 1 globals is 10.11 KiB (10352 bytes)
[01:28:08.100] The total size of the 1 globals exported for future expression ('value(a) + 1') is 10.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (10.11 KiB of class 'environment')
[01:28:08.100] - globals: [1] 'a'
[01:28:08.100] - packages: [1] 'future'
[01:28:08.100] getGlobalsAndPackages() ... DONE
[01:28:08.101] run() for 'Future' ...
[01:28:08.101] - state: 'created'
[01:28:08.101] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.101] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.102] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.102]   - Field: 'label'
[01:28:08.102]   - Field: 'local'
[01:28:08.102]   - Field: 'owner'
[01:28:08.102]   - Field: 'envir'
[01:28:08.103]   - Field: 'packages'
[01:28:08.103]   - Field: 'gc'
[01:28:08.103]   - Field: 'conditions'
[01:28:08.103]   - Field: 'expr'
[01:28:08.103]   - Field: 'uuid'
[01:28:08.103]   - Field: 'seed'
[01:28:08.104]   - Field: 'version'
[01:28:08.104]   - Field: 'result'
[01:28:08.104]   - Field: 'asynchronous'
[01:28:08.104]   - Field: 'calls'
[01:28:08.105]   - Field: 'globals'
[01:28:08.105]   - Field: 'stdout'
[01:28:08.105]   - Field: 'earlySignal'
[01:28:08.105]   - Field: 'lazy'
[01:28:08.105]   - Field: 'state'
[01:28:08.105] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.106] - Launch lazy future ...
[01:28:08.106] Packages needed by the future expression (n = 1): 'future'
[01:28:08.106] Packages needed by future strategies (n = 0): <none>
[01:28:08.107] {
[01:28:08.107]     {
[01:28:08.107]         {
[01:28:08.107]             ...future.startTime <- base::Sys.time()
[01:28:08.107]             {
[01:28:08.107]                 {
[01:28:08.107]                   {
[01:28:08.107]                     {
[01:28:08.107]                       base::local({
[01:28:08.107]                         has_future <- base::requireNamespace("future", 
[01:28:08.107]                           quietly = TRUE)
[01:28:08.107]                         if (has_future) {
[01:28:08.107]                           ns <- base::getNamespace("future")
[01:28:08.107]                           version <- ns[[".package"]][["version"]]
[01:28:08.107]                           if (is.null(version)) 
[01:28:08.107]                             version <- utils::packageVersion("future")
[01:28:08.107]                         }
[01:28:08.107]                         else {
[01:28:08.107]                           version <- NULL
[01:28:08.107]                         }
[01:28:08.107]                         if (!has_future || version < "1.8.0") {
[01:28:08.107]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.107]                             "", base::R.version$version.string), 
[01:28:08.107]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.107]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.107]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.107]                               "release", "version")], collapse = " "), 
[01:28:08.107]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.107]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.107]                             info)
[01:28:08.107]                           info <- base::paste(info, collapse = "; ")
[01:28:08.107]                           if (!has_future) {
[01:28:08.107]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.107]                               info)
[01:28:08.107]                           }
[01:28:08.107]                           else {
[01:28:08.107]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.107]                               info, version)
[01:28:08.107]                           }
[01:28:08.107]                           base::stop(msg)
[01:28:08.107]                         }
[01:28:08.107]                       })
[01:28:08.107]                     }
[01:28:08.107]                     base::local({
[01:28:08.107]                       for (pkg in "future") {
[01:28:08.107]                         base::loadNamespace(pkg)
[01:28:08.107]                         base::library(pkg, character.only = TRUE)
[01:28:08.107]                       }
[01:28:08.107]                     })
[01:28:08.107]                   }
[01:28:08.107]                   options(future.plan = NULL)
[01:28:08.107]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.107]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.107]                 }
[01:28:08.107]                 ...future.workdir <- getwd()
[01:28:08.107]             }
[01:28:08.107]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.107]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.107]         }
[01:28:08.107]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.107]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:08.107]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.107]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.107]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.107]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.107]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.107]             base::names(...future.oldOptions))
[01:28:08.107]     }
[01:28:08.107]     if (FALSE) {
[01:28:08.107]     }
[01:28:08.107]     else {
[01:28:08.107]         if (TRUE) {
[01:28:08.107]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.107]                 open = "w")
[01:28:08.107]         }
[01:28:08.107]         else {
[01:28:08.107]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.107]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.107]         }
[01:28:08.107]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.107]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.107]             base::sink(type = "output", split = FALSE)
[01:28:08.107]             base::close(...future.stdout)
[01:28:08.107]         }, add = TRUE)
[01:28:08.107]     }
[01:28:08.107]     ...future.frame <- base::sys.nframe()
[01:28:08.107]     ...future.conditions <- base::list()
[01:28:08.107]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.107]     if (FALSE) {
[01:28:08.107]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.107]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.107]     }
[01:28:08.107]     ...future.result <- base::tryCatch({
[01:28:08.107]         base::withCallingHandlers({
[01:28:08.107]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.107]                 1))
[01:28:08.107]             future::FutureResult(value = ...future.value$value, 
[01:28:08.107]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.107]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.107]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.107]                     ...future.globalenv.names))
[01:28:08.107]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.107]         }, condition = base::local({
[01:28:08.107]             c <- base::c
[01:28:08.107]             inherits <- base::inherits
[01:28:08.107]             invokeRestart <- base::invokeRestart
[01:28:08.107]             length <- base::length
[01:28:08.107]             list <- base::list
[01:28:08.107]             seq.int <- base::seq.int
[01:28:08.107]             signalCondition <- base::signalCondition
[01:28:08.107]             sys.calls <- base::sys.calls
[01:28:08.107]             `[[` <- base::`[[`
[01:28:08.107]             `+` <- base::`+`
[01:28:08.107]             `<<-` <- base::`<<-`
[01:28:08.107]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.107]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.107]                   3L)]
[01:28:08.107]             }
[01:28:08.107]             function(cond) {
[01:28:08.107]                 is_error <- inherits(cond, "error")
[01:28:08.107]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.107]                   NULL)
[01:28:08.107]                 if (is_error) {
[01:28:08.107]                   sessionInformation <- function() {
[01:28:08.107]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.107]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.107]                       search = base::search(), system = base::Sys.info())
[01:28:08.107]                   }
[01:28:08.107]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.107]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.107]                     cond$call), session = sessionInformation(), 
[01:28:08.107]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.107]                   signalCondition(cond)
[01:28:08.107]                 }
[01:28:08.107]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.107]                 "immediateCondition"))) {
[01:28:08.107]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.107]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.107]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.107]                   if (TRUE && !signal) {
[01:28:08.107]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.107]                     {
[01:28:08.107]                       inherits <- base::inherits
[01:28:08.107]                       invokeRestart <- base::invokeRestart
[01:28:08.107]                       is.null <- base::is.null
[01:28:08.107]                       muffled <- FALSE
[01:28:08.107]                       if (inherits(cond, "message")) {
[01:28:08.107]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.107]                         if (muffled) 
[01:28:08.107]                           invokeRestart("muffleMessage")
[01:28:08.107]                       }
[01:28:08.107]                       else if (inherits(cond, "warning")) {
[01:28:08.107]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.107]                         if (muffled) 
[01:28:08.107]                           invokeRestart("muffleWarning")
[01:28:08.107]                       }
[01:28:08.107]                       else if (inherits(cond, "condition")) {
[01:28:08.107]                         if (!is.null(pattern)) {
[01:28:08.107]                           computeRestarts <- base::computeRestarts
[01:28:08.107]                           grepl <- base::grepl
[01:28:08.107]                           restarts <- computeRestarts(cond)
[01:28:08.107]                           for (restart in restarts) {
[01:28:08.107]                             name <- restart$name
[01:28:08.107]                             if (is.null(name)) 
[01:28:08.107]                               next
[01:28:08.107]                             if (!grepl(pattern, name)) 
[01:28:08.107]                               next
[01:28:08.107]                             invokeRestart(restart)
[01:28:08.107]                             muffled <- TRUE
[01:28:08.107]                             break
[01:28:08.107]                           }
[01:28:08.107]                         }
[01:28:08.107]                       }
[01:28:08.107]                       invisible(muffled)
[01:28:08.107]                     }
[01:28:08.107]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.107]                   }
[01:28:08.107]                 }
[01:28:08.107]                 else {
[01:28:08.107]                   if (TRUE) {
[01:28:08.107]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.107]                     {
[01:28:08.107]                       inherits <- base::inherits
[01:28:08.107]                       invokeRestart <- base::invokeRestart
[01:28:08.107]                       is.null <- base::is.null
[01:28:08.107]                       muffled <- FALSE
[01:28:08.107]                       if (inherits(cond, "message")) {
[01:28:08.107]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.107]                         if (muffled) 
[01:28:08.107]                           invokeRestart("muffleMessage")
[01:28:08.107]                       }
[01:28:08.107]                       else if (inherits(cond, "warning")) {
[01:28:08.107]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.107]                         if (muffled) 
[01:28:08.107]                           invokeRestart("muffleWarning")
[01:28:08.107]                       }
[01:28:08.107]                       else if (inherits(cond, "condition")) {
[01:28:08.107]                         if (!is.null(pattern)) {
[01:28:08.107]                           computeRestarts <- base::computeRestarts
[01:28:08.107]                           grepl <- base::grepl
[01:28:08.107]                           restarts <- computeRestarts(cond)
[01:28:08.107]                           for (restart in restarts) {
[01:28:08.107]                             name <- restart$name
[01:28:08.107]                             if (is.null(name)) 
[01:28:08.107]                               next
[01:28:08.107]                             if (!grepl(pattern, name)) 
[01:28:08.107]                               next
[01:28:08.107]                             invokeRestart(restart)
[01:28:08.107]                             muffled <- TRUE
[01:28:08.107]                             break
[01:28:08.107]                           }
[01:28:08.107]                         }
[01:28:08.107]                       }
[01:28:08.107]                       invisible(muffled)
[01:28:08.107]                     }
[01:28:08.107]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.107]                   }
[01:28:08.107]                 }
[01:28:08.107]             }
[01:28:08.107]         }))
[01:28:08.107]     }, error = function(ex) {
[01:28:08.107]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.107]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.107]                 ...future.rng), started = ...future.startTime, 
[01:28:08.107]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.107]             version = "1.8"), class = "FutureResult")
[01:28:08.107]     }, finally = {
[01:28:08.107]         if (!identical(...future.workdir, getwd())) 
[01:28:08.107]             setwd(...future.workdir)
[01:28:08.107]         {
[01:28:08.107]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.107]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.107]             }
[01:28:08.107]             base::options(...future.oldOptions)
[01:28:08.107]             if (.Platform$OS.type == "windows") {
[01:28:08.107]                 old_names <- names(...future.oldEnvVars)
[01:28:08.107]                 envs <- base::Sys.getenv()
[01:28:08.107]                 names <- names(envs)
[01:28:08.107]                 common <- intersect(names, old_names)
[01:28:08.107]                 added <- setdiff(names, old_names)
[01:28:08.107]                 removed <- setdiff(old_names, names)
[01:28:08.107]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.107]                   envs[common]]
[01:28:08.107]                 NAMES <- toupper(changed)
[01:28:08.107]                 args <- list()
[01:28:08.107]                 for (kk in seq_along(NAMES)) {
[01:28:08.107]                   name <- changed[[kk]]
[01:28:08.107]                   NAME <- NAMES[[kk]]
[01:28:08.107]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.107]                     next
[01:28:08.107]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.107]                 }
[01:28:08.107]                 NAMES <- toupper(added)
[01:28:08.107]                 for (kk in seq_along(NAMES)) {
[01:28:08.107]                   name <- added[[kk]]
[01:28:08.107]                   NAME <- NAMES[[kk]]
[01:28:08.107]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.107]                     next
[01:28:08.107]                   args[[name]] <- ""
[01:28:08.107]                 }
[01:28:08.107]                 NAMES <- toupper(removed)
[01:28:08.107]                 for (kk in seq_along(NAMES)) {
[01:28:08.107]                   name <- removed[[kk]]
[01:28:08.107]                   NAME <- NAMES[[kk]]
[01:28:08.107]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.107]                     next
[01:28:08.107]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.107]                 }
[01:28:08.107]                 if (length(args) > 0) 
[01:28:08.107]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.107]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.107]             }
[01:28:08.107]             else {
[01:28:08.107]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.107]             }
[01:28:08.107]             {
[01:28:08.107]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.107]                   0L) {
[01:28:08.107]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.107]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.107]                   base::options(opts)
[01:28:08.107]                 }
[01:28:08.107]                 {
[01:28:08.107]                   {
[01:28:08.107]                     NULL
[01:28:08.107]                     RNGkind("Mersenne-Twister")
[01:28:08.107]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.107]                       inherits = FALSE)
[01:28:08.107]                   }
[01:28:08.107]                   options(future.plan = NULL)
[01:28:08.107]                   if (is.na(NA_character_)) 
[01:28:08.107]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.107]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.107]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.107]                   {
[01:28:08.107]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.107]                     if (!future$lazy) 
[01:28:08.107]                       future <- run(future)
[01:28:08.107]                     invisible(future)
[01:28:08.107]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.107]                 }
[01:28:08.107]             }
[01:28:08.107]         }
[01:28:08.107]     })
[01:28:08.107]     if (TRUE) {
[01:28:08.107]         base::sink(type = "output", split = FALSE)
[01:28:08.107]         if (TRUE) {
[01:28:08.107]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.107]         }
[01:28:08.107]         else {
[01:28:08.107]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.107]         }
[01:28:08.107]         base::close(...future.stdout)
[01:28:08.107]         ...future.stdout <- NULL
[01:28:08.107]     }
[01:28:08.107]     ...future.result$conditions <- ...future.conditions
[01:28:08.107]     ...future.result$finished <- base::Sys.time()
[01:28:08.107]     ...future.result
[01:28:08.107] }
[01:28:08.112] assign_globals() ...
[01:28:08.112] List of 1
[01:28:08.112]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d6649570> 
[01:28:08.112]  - attr(*, "where")=List of 1
[01:28:08.112]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.112]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.112]  - attr(*, "resolved")= logi TRUE
[01:28:08.112]  - attr(*, "total_size")= num 10352
[01:28:08.112]  - attr(*, "already-done")= logi TRUE
[01:28:08.116] - copied 'a' to environment
[01:28:08.116] assign_globals() ... done
[01:28:08.116] plan(): Setting new future strategy stack:
[01:28:08.117] List of future strategies:
[01:28:08.117] 1. sequential:
[01:28:08.117]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.117]    - tweaked: FALSE
[01:28:08.117]    - call: NULL
[01:28:08.117] plan(): nbrOfWorkers() = 1
[01:28:08.118] plan(): Setting new future strategy stack:
[01:28:08.119] List of future strategies:
[01:28:08.119] 1. sequential:
[01:28:08.119]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.119]    - tweaked: FALSE
[01:28:08.119]    - call: plan(strategy)
[01:28:08.119] plan(): nbrOfWorkers() = 1
[01:28:08.120] SequentialFuture started (and completed)
[01:28:08.120] - Launch lazy future ... done
[01:28:08.120] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.121] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.121] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:08.122] - globals found: [2] '{', 'pkg'
[01:28:08.122] Searching for globals ... DONE
[01:28:08.122] Resolving globals: TRUE
[01:28:08.122] Resolving any globals that are futures ...
[01:28:08.123] - globals: [2] '{', 'pkg'
[01:28:08.123] Resolving any globals that are futures ... DONE
[01:28:08.123] Resolving futures part of globals (recursively) ...
[01:28:08.124] resolve() on list ...
[01:28:08.124]  recursive: 99
[01:28:08.124]  length: 1
[01:28:08.124]  elements: 'pkg'
[01:28:08.124]  length: 0 (resolved future 1)
[01:28:08.124] resolve() on list ... DONE
[01:28:08.125] - globals: [1] 'pkg'
[01:28:08.125] Resolving futures part of globals (recursively) ... DONE
[01:28:08.125] The total size of the 1 globals is 112 bytes (112 bytes)
[01:28:08.125] The total size of the 1 globals exported for future expression ('{; pkg; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'pkg' (112 bytes of class 'character')
[01:28:08.126] - globals: [1] 'pkg'
[01:28:08.126] 
[01:28:08.126] getGlobalsAndPackages() ... DONE
[01:28:08.126] Packages needed by the future expression (n = 0): <none>
[01:28:08.127] Packages needed by future strategies (n = 0): <none>
[01:28:08.127] {
[01:28:08.127]     {
[01:28:08.127]         {
[01:28:08.127]             ...future.startTime <- base::Sys.time()
[01:28:08.127]             {
[01:28:08.127]                 {
[01:28:08.127]                   {
[01:28:08.127]                     base::local({
[01:28:08.127]                       has_future <- base::requireNamespace("future", 
[01:28:08.127]                         quietly = TRUE)
[01:28:08.127]                       if (has_future) {
[01:28:08.127]                         ns <- base::getNamespace("future")
[01:28:08.127]                         version <- ns[[".package"]][["version"]]
[01:28:08.127]                         if (is.null(version)) 
[01:28:08.127]                           version <- utils::packageVersion("future")
[01:28:08.127]                       }
[01:28:08.127]                       else {
[01:28:08.127]                         version <- NULL
[01:28:08.127]                       }
[01:28:08.127]                       if (!has_future || version < "1.8.0") {
[01:28:08.127]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.127]                           "", base::R.version$version.string), 
[01:28:08.127]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.127]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.127]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.127]                             "release", "version")], collapse = " "), 
[01:28:08.127]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.127]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.127]                           info)
[01:28:08.127]                         info <- base::paste(info, collapse = "; ")
[01:28:08.127]                         if (!has_future) {
[01:28:08.127]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.127]                             info)
[01:28:08.127]                         }
[01:28:08.127]                         else {
[01:28:08.127]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.127]                             info, version)
[01:28:08.127]                         }
[01:28:08.127]                         base::stop(msg)
[01:28:08.127]                       }
[01:28:08.127]                     })
[01:28:08.127]                   }
[01:28:08.127]                   options(future.plan = NULL)
[01:28:08.127]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.127]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.127]                 }
[01:28:08.127]                 ...future.workdir <- getwd()
[01:28:08.127]             }
[01:28:08.127]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.127]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.127]         }
[01:28:08.127]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.127]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:08.127]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.127]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.127]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.127]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.127]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.127]             base::names(...future.oldOptions))
[01:28:08.127]     }
[01:28:08.127]     if (FALSE) {
[01:28:08.127]     }
[01:28:08.127]     else {
[01:28:08.127]         if (TRUE) {
[01:28:08.127]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.127]                 open = "w")
[01:28:08.127]         }
[01:28:08.127]         else {
[01:28:08.127]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.127]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.127]         }
[01:28:08.127]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.127]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.127]             base::sink(type = "output", split = FALSE)
[01:28:08.127]             base::close(...future.stdout)
[01:28:08.127]         }, add = TRUE)
[01:28:08.127]     }
[01:28:08.127]     ...future.frame <- base::sys.nframe()
[01:28:08.127]     ...future.conditions <- base::list()
[01:28:08.127]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.127]     if (FALSE) {
[01:28:08.127]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.127]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.127]     }
[01:28:08.127]     ...future.result <- base::tryCatch({
[01:28:08.127]         base::withCallingHandlers({
[01:28:08.127]             ...future.value <- base::withVisible(base::local({
[01:28:08.127]                 pkg
[01:28:08.127]             }))
[01:28:08.127]             future::FutureResult(value = ...future.value$value, 
[01:28:08.127]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.127]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.127]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.127]                     ...future.globalenv.names))
[01:28:08.127]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.127]         }, condition = base::local({
[01:28:08.127]             c <- base::c
[01:28:08.127]             inherits <- base::inherits
[01:28:08.127]             invokeRestart <- base::invokeRestart
[01:28:08.127]             length <- base::length
[01:28:08.127]             list <- base::list
[01:28:08.127]             seq.int <- base::seq.int
[01:28:08.127]             signalCondition <- base::signalCondition
[01:28:08.127]             sys.calls <- base::sys.calls
[01:28:08.127]             `[[` <- base::`[[`
[01:28:08.127]             `+` <- base::`+`
[01:28:08.127]             `<<-` <- base::`<<-`
[01:28:08.127]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.127]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.127]                   3L)]
[01:28:08.127]             }
[01:28:08.127]             function(cond) {
[01:28:08.127]                 is_error <- inherits(cond, "error")
[01:28:08.127]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.127]                   NULL)
[01:28:08.127]                 if (is_error) {
[01:28:08.127]                   sessionInformation <- function() {
[01:28:08.127]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.127]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.127]                       search = base::search(), system = base::Sys.info())
[01:28:08.127]                   }
[01:28:08.127]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.127]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.127]                     cond$call), session = sessionInformation(), 
[01:28:08.127]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.127]                   signalCondition(cond)
[01:28:08.127]                 }
[01:28:08.127]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.127]                 "immediateCondition"))) {
[01:28:08.127]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.127]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.127]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.127]                   if (TRUE && !signal) {
[01:28:08.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.127]                     {
[01:28:08.127]                       inherits <- base::inherits
[01:28:08.127]                       invokeRestart <- base::invokeRestart
[01:28:08.127]                       is.null <- base::is.null
[01:28:08.127]                       muffled <- FALSE
[01:28:08.127]                       if (inherits(cond, "message")) {
[01:28:08.127]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.127]                         if (muffled) 
[01:28:08.127]                           invokeRestart("muffleMessage")
[01:28:08.127]                       }
[01:28:08.127]                       else if (inherits(cond, "warning")) {
[01:28:08.127]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.127]                         if (muffled) 
[01:28:08.127]                           invokeRestart("muffleWarning")
[01:28:08.127]                       }
[01:28:08.127]                       else if (inherits(cond, "condition")) {
[01:28:08.127]                         if (!is.null(pattern)) {
[01:28:08.127]                           computeRestarts <- base::computeRestarts
[01:28:08.127]                           grepl <- base::grepl
[01:28:08.127]                           restarts <- computeRestarts(cond)
[01:28:08.127]                           for (restart in restarts) {
[01:28:08.127]                             name <- restart$name
[01:28:08.127]                             if (is.null(name)) 
[01:28:08.127]                               next
[01:28:08.127]                             if (!grepl(pattern, name)) 
[01:28:08.127]                               next
[01:28:08.127]                             invokeRestart(restart)
[01:28:08.127]                             muffled <- TRUE
[01:28:08.127]                             break
[01:28:08.127]                           }
[01:28:08.127]                         }
[01:28:08.127]                       }
[01:28:08.127]                       invisible(muffled)
[01:28:08.127]                     }
[01:28:08.127]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.127]                   }
[01:28:08.127]                 }
[01:28:08.127]                 else {
[01:28:08.127]                   if (TRUE) {
[01:28:08.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.127]                     {
[01:28:08.127]                       inherits <- base::inherits
[01:28:08.127]                       invokeRestart <- base::invokeRestart
[01:28:08.127]                       is.null <- base::is.null
[01:28:08.127]                       muffled <- FALSE
[01:28:08.127]                       if (inherits(cond, "message")) {
[01:28:08.127]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.127]                         if (muffled) 
[01:28:08.127]                           invokeRestart("muffleMessage")
[01:28:08.127]                       }
[01:28:08.127]                       else if (inherits(cond, "warning")) {
[01:28:08.127]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.127]                         if (muffled) 
[01:28:08.127]                           invokeRestart("muffleWarning")
[01:28:08.127]                       }
[01:28:08.127]                       else if (inherits(cond, "condition")) {
[01:28:08.127]                         if (!is.null(pattern)) {
[01:28:08.127]                           computeRestarts <- base::computeRestarts
[01:28:08.127]                           grepl <- base::grepl
[01:28:08.127]                           restarts <- computeRestarts(cond)
[01:28:08.127]                           for (restart in restarts) {
[01:28:08.127]                             name <- restart$name
[01:28:08.127]                             if (is.null(name)) 
[01:28:08.127]                               next
[01:28:08.127]                             if (!grepl(pattern, name)) 
[01:28:08.127]                               next
[01:28:08.127]                             invokeRestart(restart)
[01:28:08.127]                             muffled <- TRUE
[01:28:08.127]                             break
[01:28:08.127]                           }
[01:28:08.127]                         }
[01:28:08.127]                       }
[01:28:08.127]                       invisible(muffled)
[01:28:08.127]                     }
[01:28:08.127]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.127]                   }
[01:28:08.127]                 }
[01:28:08.127]             }
[01:28:08.127]         }))
[01:28:08.127]     }, error = function(ex) {
[01:28:08.127]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.127]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.127]                 ...future.rng), started = ...future.startTime, 
[01:28:08.127]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.127]             version = "1.8"), class = "FutureResult")
[01:28:08.127]     }, finally = {
[01:28:08.127]         if (!identical(...future.workdir, getwd())) 
[01:28:08.127]             setwd(...future.workdir)
[01:28:08.127]         {
[01:28:08.127]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.127]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.127]             }
[01:28:08.127]             base::options(...future.oldOptions)
[01:28:08.127]             if (.Platform$OS.type == "windows") {
[01:28:08.127]                 old_names <- names(...future.oldEnvVars)
[01:28:08.127]                 envs <- base::Sys.getenv()
[01:28:08.127]                 names <- names(envs)
[01:28:08.127]                 common <- intersect(names, old_names)
[01:28:08.127]                 added <- setdiff(names, old_names)
[01:28:08.127]                 removed <- setdiff(old_names, names)
[01:28:08.127]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.127]                   envs[common]]
[01:28:08.127]                 NAMES <- toupper(changed)
[01:28:08.127]                 args <- list()
[01:28:08.127]                 for (kk in seq_along(NAMES)) {
[01:28:08.127]                   name <- changed[[kk]]
[01:28:08.127]                   NAME <- NAMES[[kk]]
[01:28:08.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.127]                     next
[01:28:08.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.127]                 }
[01:28:08.127]                 NAMES <- toupper(added)
[01:28:08.127]                 for (kk in seq_along(NAMES)) {
[01:28:08.127]                   name <- added[[kk]]
[01:28:08.127]                   NAME <- NAMES[[kk]]
[01:28:08.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.127]                     next
[01:28:08.127]                   args[[name]] <- ""
[01:28:08.127]                 }
[01:28:08.127]                 NAMES <- toupper(removed)
[01:28:08.127]                 for (kk in seq_along(NAMES)) {
[01:28:08.127]                   name <- removed[[kk]]
[01:28:08.127]                   NAME <- NAMES[[kk]]
[01:28:08.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.127]                     next
[01:28:08.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.127]                 }
[01:28:08.127]                 if (length(args) > 0) 
[01:28:08.127]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.127]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.127]             }
[01:28:08.127]             else {
[01:28:08.127]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.127]             }
[01:28:08.127]             {
[01:28:08.127]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.127]                   0L) {
[01:28:08.127]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.127]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.127]                   base::options(opts)
[01:28:08.127]                 }
[01:28:08.127]                 {
[01:28:08.127]                   {
[01:28:08.127]                     NULL
[01:28:08.127]                     RNGkind("Mersenne-Twister")
[01:28:08.127]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.127]                       inherits = FALSE)
[01:28:08.127]                   }
[01:28:08.127]                   options(future.plan = NULL)
[01:28:08.127]                   if (is.na(NA_character_)) 
[01:28:08.127]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.127]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.127]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.127]                   {
[01:28:08.127]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.127]                     if (!future$lazy) 
[01:28:08.127]                       future <- run(future)
[01:28:08.127]                     invisible(future)
[01:28:08.127]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.127]                 }
[01:28:08.127]             }
[01:28:08.127]         }
[01:28:08.127]     })
[01:28:08.127]     if (TRUE) {
[01:28:08.127]         base::sink(type = "output", split = FALSE)
[01:28:08.127]         if (TRUE) {
[01:28:08.127]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.127]         }
[01:28:08.127]         else {
[01:28:08.127]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.127]         }
[01:28:08.127]         base::close(...future.stdout)
[01:28:08.127]         ...future.stdout <- NULL
[01:28:08.127]     }
[01:28:08.127]     ...future.result$conditions <- ...future.conditions
[01:28:08.127]     ...future.result$finished <- base::Sys.time()
[01:28:08.127]     ...future.result
[01:28:08.127] }
[01:28:08.131] assign_globals() ...
[01:28:08.131] List of 1
[01:28:08.131]  $ pkg: chr "foo"
[01:28:08.131]  - attr(*, "where")=List of 1
[01:28:08.131]   ..$ pkg:<environment: R_EmptyEnv> 
[01:28:08.131]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.131]  - attr(*, "resolved")= logi TRUE
[01:28:08.131]  - attr(*, "total_size")= num 112
[01:28:08.134] - copied 'pkg' to environment
[01:28:08.134] assign_globals() ... done
[01:28:08.134] plan(): Setting new future strategy stack:
[01:28:08.134] List of future strategies:
[01:28:08.134] 1. sequential:
[01:28:08.134]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.134]    - tweaked: FALSE
[01:28:08.134]    - call: NULL
[01:28:08.135] plan(): nbrOfWorkers() = 1
[01:28:08.136] plan(): Setting new future strategy stack:
[01:28:08.136] List of future strategies:
[01:28:08.136] 1. sequential:
[01:28:08.136]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.136]    - tweaked: FALSE
[01:28:08.136]    - call: plan(strategy)
[01:28:08.137] plan(): nbrOfWorkers() = 1
[01:28:08.137] SequentialFuture started (and completed)
value(f) = 'foo'
Method for identifying globals: 'conservative' ... DONE
Method for identifying globals: 'ordered' ...
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.138] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.138] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.143] - globals found: [4] '{', '<-', 'a', '*'
[01:28:08.143] Searching for globals ... DONE
[01:28:08.143] Resolving globals: TRUE
[01:28:08.143] Resolving any globals that are futures ...
[01:28:08.144] - globals: [4] '{', '<-', 'a', '*'
[01:28:08.144] Resolving any globals that are futures ... DONE
[01:28:08.144] Resolving futures part of globals (recursively) ...
[01:28:08.145] resolve() on list ...
[01:28:08.145]  recursive: 99
[01:28:08.145]  length: 1
[01:28:08.145]  elements: 'a'
[01:28:08.145]  length: 0 (resolved future 1)
[01:28:08.145] resolve() on list ... DONE
[01:28:08.146] - globals: [1] 'a'
[01:28:08.146] Resolving futures part of globals (recursively) ... DONE
[01:28:08.146] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:08.146] The total size of the 1 globals exported for future expression ('{; b <- a; a <- 2; a * b; }') 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:08.147] - globals: [1] 'a'
[01:28:08.147] 
[01:28:08.147] getGlobalsAndPackages() ... DONE
[01:28:08.147] run() for 'Future' ...
[01:28:08.147] - state: 'created'
[01:28:08.148] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.148] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.148] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.148]   - Field: 'label'
[01:28:08.149]   - Field: 'local'
[01:28:08.149]   - Field: 'owner'
[01:28:08.149]   - Field: 'envir'
[01:28:08.149]   - Field: 'packages'
[01:28:08.149]   - Field: 'gc'
[01:28:08.149]   - Field: 'conditions'
[01:28:08.150]   - Field: 'expr'
[01:28:08.150]   - Field: 'uuid'
[01:28:08.150]   - Field: 'seed'
[01:28:08.150]   - Field: 'version'
[01:28:08.150]   - Field: 'result'
[01:28:08.151]   - Field: 'asynchronous'
[01:28:08.151]   - Field: 'calls'
[01:28:08.151]   - Field: 'globals'
[01:28:08.151]   - Field: 'stdout'
[01:28:08.151]   - Field: 'earlySignal'
[01:28:08.152]   - Field: 'lazy'
[01:28:08.152]   - Field: 'state'
[01:28:08.152] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.152] - Launch lazy future ...
[01:28:08.152] Packages needed by the future expression (n = 0): <none>
[01:28:08.153] Packages needed by future strategies (n = 0): <none>
[01:28:08.153] {
[01:28:08.153]     {
[01:28:08.153]         {
[01:28:08.153]             ...future.startTime <- base::Sys.time()
[01:28:08.153]             {
[01:28:08.153]                 {
[01:28:08.153]                   {
[01:28:08.153]                     base::local({
[01:28:08.153]                       has_future <- base::requireNamespace("future", 
[01:28:08.153]                         quietly = TRUE)
[01:28:08.153]                       if (has_future) {
[01:28:08.153]                         ns <- base::getNamespace("future")
[01:28:08.153]                         version <- ns[[".package"]][["version"]]
[01:28:08.153]                         if (is.null(version)) 
[01:28:08.153]                           version <- utils::packageVersion("future")
[01:28:08.153]                       }
[01:28:08.153]                       else {
[01:28:08.153]                         version <- NULL
[01:28:08.153]                       }
[01:28:08.153]                       if (!has_future || version < "1.8.0") {
[01:28:08.153]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.153]                           "", base::R.version$version.string), 
[01:28:08.153]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.153]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.153]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.153]                             "release", "version")], collapse = " "), 
[01:28:08.153]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.153]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.153]                           info)
[01:28:08.153]                         info <- base::paste(info, collapse = "; ")
[01:28:08.153]                         if (!has_future) {
[01:28:08.153]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.153]                             info)
[01:28:08.153]                         }
[01:28:08.153]                         else {
[01:28:08.153]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.153]                             info, version)
[01:28:08.153]                         }
[01:28:08.153]                         base::stop(msg)
[01:28:08.153]                       }
[01:28:08.153]                     })
[01:28:08.153]                   }
[01:28:08.153]                   options(future.plan = NULL)
[01:28:08.153]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.153]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.153]                 }
[01:28:08.153]                 ...future.workdir <- getwd()
[01:28:08.153]             }
[01:28:08.153]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.153]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.153]         }
[01:28:08.153]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.153]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.153]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.153]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.153]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.153]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.153]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.153]             base::names(...future.oldOptions))
[01:28:08.153]     }
[01:28:08.153]     if (FALSE) {
[01:28:08.153]     }
[01:28:08.153]     else {
[01:28:08.153]         if (TRUE) {
[01:28:08.153]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.153]                 open = "w")
[01:28:08.153]         }
[01:28:08.153]         else {
[01:28:08.153]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.153]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.153]         }
[01:28:08.153]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.153]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.153]             base::sink(type = "output", split = FALSE)
[01:28:08.153]             base::close(...future.stdout)
[01:28:08.153]         }, add = TRUE)
[01:28:08.153]     }
[01:28:08.153]     ...future.frame <- base::sys.nframe()
[01:28:08.153]     ...future.conditions <- base::list()
[01:28:08.153]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.153]     if (FALSE) {
[01:28:08.153]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.153]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.153]     }
[01:28:08.153]     ...future.result <- base::tryCatch({
[01:28:08.153]         base::withCallingHandlers({
[01:28:08.153]             ...future.value <- base::withVisible(base::local({
[01:28:08.153]                 b <- a
[01:28:08.153]                 a <- 2
[01:28:08.153]                 a * b
[01:28:08.153]             }))
[01:28:08.153]             future::FutureResult(value = ...future.value$value, 
[01:28:08.153]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.153]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.153]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.153]                     ...future.globalenv.names))
[01:28:08.153]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.153]         }, condition = base::local({
[01:28:08.153]             c <- base::c
[01:28:08.153]             inherits <- base::inherits
[01:28:08.153]             invokeRestart <- base::invokeRestart
[01:28:08.153]             length <- base::length
[01:28:08.153]             list <- base::list
[01:28:08.153]             seq.int <- base::seq.int
[01:28:08.153]             signalCondition <- base::signalCondition
[01:28:08.153]             sys.calls <- base::sys.calls
[01:28:08.153]             `[[` <- base::`[[`
[01:28:08.153]             `+` <- base::`+`
[01:28:08.153]             `<<-` <- base::`<<-`
[01:28:08.153]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.153]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.153]                   3L)]
[01:28:08.153]             }
[01:28:08.153]             function(cond) {
[01:28:08.153]                 is_error <- inherits(cond, "error")
[01:28:08.153]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.153]                   NULL)
[01:28:08.153]                 if (is_error) {
[01:28:08.153]                   sessionInformation <- function() {
[01:28:08.153]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.153]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.153]                       search = base::search(), system = base::Sys.info())
[01:28:08.153]                   }
[01:28:08.153]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.153]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.153]                     cond$call), session = sessionInformation(), 
[01:28:08.153]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.153]                   signalCondition(cond)
[01:28:08.153]                 }
[01:28:08.153]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.153]                 "immediateCondition"))) {
[01:28:08.153]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.153]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.153]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.153]                   if (TRUE && !signal) {
[01:28:08.153]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.153]                     {
[01:28:08.153]                       inherits <- base::inherits
[01:28:08.153]                       invokeRestart <- base::invokeRestart
[01:28:08.153]                       is.null <- base::is.null
[01:28:08.153]                       muffled <- FALSE
[01:28:08.153]                       if (inherits(cond, "message")) {
[01:28:08.153]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.153]                         if (muffled) 
[01:28:08.153]                           invokeRestart("muffleMessage")
[01:28:08.153]                       }
[01:28:08.153]                       else if (inherits(cond, "warning")) {
[01:28:08.153]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.153]                         if (muffled) 
[01:28:08.153]                           invokeRestart("muffleWarning")
[01:28:08.153]                       }
[01:28:08.153]                       else if (inherits(cond, "condition")) {
[01:28:08.153]                         if (!is.null(pattern)) {
[01:28:08.153]                           computeRestarts <- base::computeRestarts
[01:28:08.153]                           grepl <- base::grepl
[01:28:08.153]                           restarts <- computeRestarts(cond)
[01:28:08.153]                           for (restart in restarts) {
[01:28:08.153]                             name <- restart$name
[01:28:08.153]                             if (is.null(name)) 
[01:28:08.153]                               next
[01:28:08.153]                             if (!grepl(pattern, name)) 
[01:28:08.153]                               next
[01:28:08.153]                             invokeRestart(restart)
[01:28:08.153]                             muffled <- TRUE
[01:28:08.153]                             break
[01:28:08.153]                           }
[01:28:08.153]                         }
[01:28:08.153]                       }
[01:28:08.153]                       invisible(muffled)
[01:28:08.153]                     }
[01:28:08.153]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.153]                   }
[01:28:08.153]                 }
[01:28:08.153]                 else {
[01:28:08.153]                   if (TRUE) {
[01:28:08.153]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.153]                     {
[01:28:08.153]                       inherits <- base::inherits
[01:28:08.153]                       invokeRestart <- base::invokeRestart
[01:28:08.153]                       is.null <- base::is.null
[01:28:08.153]                       muffled <- FALSE
[01:28:08.153]                       if (inherits(cond, "message")) {
[01:28:08.153]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.153]                         if (muffled) 
[01:28:08.153]                           invokeRestart("muffleMessage")
[01:28:08.153]                       }
[01:28:08.153]                       else if (inherits(cond, "warning")) {
[01:28:08.153]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.153]                         if (muffled) 
[01:28:08.153]                           invokeRestart("muffleWarning")
[01:28:08.153]                       }
[01:28:08.153]                       else if (inherits(cond, "condition")) {
[01:28:08.153]                         if (!is.null(pattern)) {
[01:28:08.153]                           computeRestarts <- base::computeRestarts
[01:28:08.153]                           grepl <- base::grepl
[01:28:08.153]                           restarts <- computeRestarts(cond)
[01:28:08.153]                           for (restart in restarts) {
[01:28:08.153]                             name <- restart$name
[01:28:08.153]                             if (is.null(name)) 
[01:28:08.153]                               next
[01:28:08.153]                             if (!grepl(pattern, name)) 
[01:28:08.153]                               next
[01:28:08.153]                             invokeRestart(restart)
[01:28:08.153]                             muffled <- TRUE
[01:28:08.153]                             break
[01:28:08.153]                           }
[01:28:08.153]                         }
[01:28:08.153]                       }
[01:28:08.153]                       invisible(muffled)
[01:28:08.153]                     }
[01:28:08.153]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.153]                   }
[01:28:08.153]                 }
[01:28:08.153]             }
[01:28:08.153]         }))
[01:28:08.153]     }, error = function(ex) {
[01:28:08.153]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.153]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.153]                 ...future.rng), started = ...future.startTime, 
[01:28:08.153]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.153]             version = "1.8"), class = "FutureResult")
[01:28:08.153]     }, finally = {
[01:28:08.153]         if (!identical(...future.workdir, getwd())) 
[01:28:08.153]             setwd(...future.workdir)
[01:28:08.153]         {
[01:28:08.153]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.153]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.153]             }
[01:28:08.153]             base::options(...future.oldOptions)
[01:28:08.153]             if (.Platform$OS.type == "windows") {
[01:28:08.153]                 old_names <- names(...future.oldEnvVars)
[01:28:08.153]                 envs <- base::Sys.getenv()
[01:28:08.153]                 names <- names(envs)
[01:28:08.153]                 common <- intersect(names, old_names)
[01:28:08.153]                 added <- setdiff(names, old_names)
[01:28:08.153]                 removed <- setdiff(old_names, names)
[01:28:08.153]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.153]                   envs[common]]
[01:28:08.153]                 NAMES <- toupper(changed)
[01:28:08.153]                 args <- list()
[01:28:08.153]                 for (kk in seq_along(NAMES)) {
[01:28:08.153]                   name <- changed[[kk]]
[01:28:08.153]                   NAME <- NAMES[[kk]]
[01:28:08.153]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.153]                     next
[01:28:08.153]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.153]                 }
[01:28:08.153]                 NAMES <- toupper(added)
[01:28:08.153]                 for (kk in seq_along(NAMES)) {
[01:28:08.153]                   name <- added[[kk]]
[01:28:08.153]                   NAME <- NAMES[[kk]]
[01:28:08.153]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.153]                     next
[01:28:08.153]                   args[[name]] <- ""
[01:28:08.153]                 }
[01:28:08.153]                 NAMES <- toupper(removed)
[01:28:08.153]                 for (kk in seq_along(NAMES)) {
[01:28:08.153]                   name <- removed[[kk]]
[01:28:08.153]                   NAME <- NAMES[[kk]]
[01:28:08.153]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.153]                     next
[01:28:08.153]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.153]                 }
[01:28:08.153]                 if (length(args) > 0) 
[01:28:08.153]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.153]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.153]             }
[01:28:08.153]             else {
[01:28:08.153]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.153]             }
[01:28:08.153]             {
[01:28:08.153]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.153]                   0L) {
[01:28:08.153]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.153]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.153]                   base::options(opts)
[01:28:08.153]                 }
[01:28:08.153]                 {
[01:28:08.153]                   {
[01:28:08.153]                     NULL
[01:28:08.153]                     RNGkind("Mersenne-Twister")
[01:28:08.153]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.153]                       inherits = FALSE)
[01:28:08.153]                   }
[01:28:08.153]                   options(future.plan = NULL)
[01:28:08.153]                   if (is.na(NA_character_)) 
[01:28:08.153]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.153]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.153]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.153]                   {
[01:28:08.153]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.153]                     if (!future$lazy) 
[01:28:08.153]                       future <- run(future)
[01:28:08.153]                     invisible(future)
[01:28:08.153]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.153]                 }
[01:28:08.153]             }
[01:28:08.153]         }
[01:28:08.153]     })
[01:28:08.153]     if (TRUE) {
[01:28:08.153]         base::sink(type = "output", split = FALSE)
[01:28:08.153]         if (TRUE) {
[01:28:08.153]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.153]         }
[01:28:08.153]         else {
[01:28:08.153]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.153]         }
[01:28:08.153]         base::close(...future.stdout)
[01:28:08.153]         ...future.stdout <- NULL
[01:28:08.153]     }
[01:28:08.153]     ...future.result$conditions <- ...future.conditions
[01:28:08.153]     ...future.result$finished <- base::Sys.time()
[01:28:08.153]     ...future.result
[01:28:08.153] }
[01:28:08.157] assign_globals() ...
[01:28:08.157] List of 1
[01:28:08.157]  $ a: num 3
[01:28:08.157]  - attr(*, "where")=List of 1
[01:28:08.157]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.157]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.157]  - attr(*, "resolved")= logi TRUE
[01:28:08.157]  - attr(*, "total_size")= num 56
[01:28:08.157]  - attr(*, "already-done")= logi TRUE
[01:28:08.160] - copied 'a' to environment
[01:28:08.160] assign_globals() ... done
[01:28:08.161] plan(): Setting new future strategy stack:
[01:28:08.161] List of future strategies:
[01:28:08.161] 1. sequential:
[01:28:08.161]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.161]    - tweaked: FALSE
[01:28:08.161]    - call: NULL
[01:28:08.161] plan(): nbrOfWorkers() = 1
[01:28:08.162] plan(): Setting new future strategy stack:
[01:28:08.163] List of future strategies:
[01:28:08.163] 1. sequential:
[01:28:08.163]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.163]    - tweaked: FALSE
[01:28:08.163]    - call: plan(strategy)
[01:28:08.163] plan(): nbrOfWorkers() = 1
[01:28:08.164] SequentialFuture started (and completed)
[01:28:08.164] - Launch lazy future ... done
[01:28:08.164] run() for 'SequentialFuture' ... done
y = 6
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.165] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.165] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.167] - globals found: [4] '{', '<-', 'a', '*'
[01:28:08.167] Searching for globals ... DONE
[01:28:08.168] Resolving globals: TRUE
[01:28:08.168] Resolving any globals that are futures ...
[01:28:08.168] - globals: [4] '{', '<-', 'a', '*'
[01:28:08.168] Resolving any globals that are futures ... DONE
[01:28:08.169] Resolving futures part of globals (recursively) ...
[01:28:08.169] resolve() on list ...
[01:28:08.169]  recursive: 99
[01:28:08.169]  length: 1
[01:28:08.169]  elements: 'a'
[01:28:08.170]  length: 0 (resolved future 1)
[01:28:08.170] resolve() on list ... DONE
[01:28:08.170] - globals: [1] 'a'
[01:28:08.170] Resolving futures part of globals (recursively) ... DONE
[01:28:08.170] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:08.171] The total size of the 1 globals exported for future expression ('{; b <- a; a <- 2; a * b; }') 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:08.171] - globals: [1] 'a'
[01:28:08.171] 
[01:28:08.171] getGlobalsAndPackages() ... DONE
[01:28:08.173] run() for 'Future' ...
[01:28:08.173] - state: 'created'
[01:28:08.174] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.174] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.174] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.174]   - Field: 'label'
[01:28:08.175]   - Field: 'local'
[01:28:08.175]   - Field: 'owner'
[01:28:08.175]   - Field: 'envir'
[01:28:08.175]   - Field: 'packages'
[01:28:08.175]   - Field: 'gc'
[01:28:08.175]   - Field: 'conditions'
[01:28:08.176]   - Field: 'expr'
[01:28:08.176]   - Field: 'uuid'
[01:28:08.176]   - Field: 'seed'
[01:28:08.176]   - Field: 'version'
[01:28:08.176]   - Field: 'result'
[01:28:08.176]   - Field: 'asynchronous'
[01:28:08.177]   - Field: 'calls'
[01:28:08.177]   - Field: 'globals'
[01:28:08.177]   - Field: 'stdout'
[01:28:08.177]   - Field: 'earlySignal'
[01:28:08.177]   - Field: 'lazy'
[01:28:08.178]   - Field: 'state'
[01:28:08.178] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.178] - Launch lazy future ...
[01:28:08.178] Packages needed by the future expression (n = 0): <none>
[01:28:08.178] Packages needed by future strategies (n = 0): <none>
[01:28:08.179] {
[01:28:08.179]     {
[01:28:08.179]         {
[01:28:08.179]             ...future.startTime <- base::Sys.time()
[01:28:08.179]             {
[01:28:08.179]                 {
[01:28:08.179]                   {
[01:28:08.179]                     base::local({
[01:28:08.179]                       has_future <- base::requireNamespace("future", 
[01:28:08.179]                         quietly = TRUE)
[01:28:08.179]                       if (has_future) {
[01:28:08.179]                         ns <- base::getNamespace("future")
[01:28:08.179]                         version <- ns[[".package"]][["version"]]
[01:28:08.179]                         if (is.null(version)) 
[01:28:08.179]                           version <- utils::packageVersion("future")
[01:28:08.179]                       }
[01:28:08.179]                       else {
[01:28:08.179]                         version <- NULL
[01:28:08.179]                       }
[01:28:08.179]                       if (!has_future || version < "1.8.0") {
[01:28:08.179]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.179]                           "", base::R.version$version.string), 
[01:28:08.179]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.179]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.179]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.179]                             "release", "version")], collapse = " "), 
[01:28:08.179]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.179]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.179]                           info)
[01:28:08.179]                         info <- base::paste(info, collapse = "; ")
[01:28:08.179]                         if (!has_future) {
[01:28:08.179]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.179]                             info)
[01:28:08.179]                         }
[01:28:08.179]                         else {
[01:28:08.179]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.179]                             info, version)
[01:28:08.179]                         }
[01:28:08.179]                         base::stop(msg)
[01:28:08.179]                       }
[01:28:08.179]                     })
[01:28:08.179]                   }
[01:28:08.179]                   options(future.plan = NULL)
[01:28:08.179]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.179]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.179]                 }
[01:28:08.179]                 ...future.workdir <- getwd()
[01:28:08.179]             }
[01:28:08.179]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.179]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.179]         }
[01:28:08.179]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.179]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.179]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.179]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.179]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.179]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.179]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.179]             base::names(...future.oldOptions))
[01:28:08.179]     }
[01:28:08.179]     if (FALSE) {
[01:28:08.179]     }
[01:28:08.179]     else {
[01:28:08.179]         if (TRUE) {
[01:28:08.179]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.179]                 open = "w")
[01:28:08.179]         }
[01:28:08.179]         else {
[01:28:08.179]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.179]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.179]         }
[01:28:08.179]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.179]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.179]             base::sink(type = "output", split = FALSE)
[01:28:08.179]             base::close(...future.stdout)
[01:28:08.179]         }, add = TRUE)
[01:28:08.179]     }
[01:28:08.179]     ...future.frame <- base::sys.nframe()
[01:28:08.179]     ...future.conditions <- base::list()
[01:28:08.179]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.179]     if (FALSE) {
[01:28:08.179]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.179]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.179]     }
[01:28:08.179]     ...future.result <- base::tryCatch({
[01:28:08.179]         base::withCallingHandlers({
[01:28:08.179]             ...future.value <- base::withVisible(base::local({
[01:28:08.179]                 b <- a
[01:28:08.179]                 a <- 2
[01:28:08.179]                 a * b
[01:28:08.179]             }))
[01:28:08.179]             future::FutureResult(value = ...future.value$value, 
[01:28:08.179]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.179]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.179]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.179]                     ...future.globalenv.names))
[01:28:08.179]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.179]         }, condition = base::local({
[01:28:08.179]             c <- base::c
[01:28:08.179]             inherits <- base::inherits
[01:28:08.179]             invokeRestart <- base::invokeRestart
[01:28:08.179]             length <- base::length
[01:28:08.179]             list <- base::list
[01:28:08.179]             seq.int <- base::seq.int
[01:28:08.179]             signalCondition <- base::signalCondition
[01:28:08.179]             sys.calls <- base::sys.calls
[01:28:08.179]             `[[` <- base::`[[`
[01:28:08.179]             `+` <- base::`+`
[01:28:08.179]             `<<-` <- base::`<<-`
[01:28:08.179]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.179]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.179]                   3L)]
[01:28:08.179]             }
[01:28:08.179]             function(cond) {
[01:28:08.179]                 is_error <- inherits(cond, "error")
[01:28:08.179]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.179]                   NULL)
[01:28:08.179]                 if (is_error) {
[01:28:08.179]                   sessionInformation <- function() {
[01:28:08.179]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.179]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.179]                       search = base::search(), system = base::Sys.info())
[01:28:08.179]                   }
[01:28:08.179]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.179]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.179]                     cond$call), session = sessionInformation(), 
[01:28:08.179]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.179]                   signalCondition(cond)
[01:28:08.179]                 }
[01:28:08.179]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.179]                 "immediateCondition"))) {
[01:28:08.179]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.179]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.179]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.179]                   if (TRUE && !signal) {
[01:28:08.179]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.179]                     {
[01:28:08.179]                       inherits <- base::inherits
[01:28:08.179]                       invokeRestart <- base::invokeRestart
[01:28:08.179]                       is.null <- base::is.null
[01:28:08.179]                       muffled <- FALSE
[01:28:08.179]                       if (inherits(cond, "message")) {
[01:28:08.179]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.179]                         if (muffled) 
[01:28:08.179]                           invokeRestart("muffleMessage")
[01:28:08.179]                       }
[01:28:08.179]                       else if (inherits(cond, "warning")) {
[01:28:08.179]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.179]                         if (muffled) 
[01:28:08.179]                           invokeRestart("muffleWarning")
[01:28:08.179]                       }
[01:28:08.179]                       else if (inherits(cond, "condition")) {
[01:28:08.179]                         if (!is.null(pattern)) {
[01:28:08.179]                           computeRestarts <- base::computeRestarts
[01:28:08.179]                           grepl <- base::grepl
[01:28:08.179]                           restarts <- computeRestarts(cond)
[01:28:08.179]                           for (restart in restarts) {
[01:28:08.179]                             name <- restart$name
[01:28:08.179]                             if (is.null(name)) 
[01:28:08.179]                               next
[01:28:08.179]                             if (!grepl(pattern, name)) 
[01:28:08.179]                               next
[01:28:08.179]                             invokeRestart(restart)
[01:28:08.179]                             muffled <- TRUE
[01:28:08.179]                             break
[01:28:08.179]                           }
[01:28:08.179]                         }
[01:28:08.179]                       }
[01:28:08.179]                       invisible(muffled)
[01:28:08.179]                     }
[01:28:08.179]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.179]                   }
[01:28:08.179]                 }
[01:28:08.179]                 else {
[01:28:08.179]                   if (TRUE) {
[01:28:08.179]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.179]                     {
[01:28:08.179]                       inherits <- base::inherits
[01:28:08.179]                       invokeRestart <- base::invokeRestart
[01:28:08.179]                       is.null <- base::is.null
[01:28:08.179]                       muffled <- FALSE
[01:28:08.179]                       if (inherits(cond, "message")) {
[01:28:08.179]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.179]                         if (muffled) 
[01:28:08.179]                           invokeRestart("muffleMessage")
[01:28:08.179]                       }
[01:28:08.179]                       else if (inherits(cond, "warning")) {
[01:28:08.179]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.179]                         if (muffled) 
[01:28:08.179]                           invokeRestart("muffleWarning")
[01:28:08.179]                       }
[01:28:08.179]                       else if (inherits(cond, "condition")) {
[01:28:08.179]                         if (!is.null(pattern)) {
[01:28:08.179]                           computeRestarts <- base::computeRestarts
[01:28:08.179]                           grepl <- base::grepl
[01:28:08.179]                           restarts <- computeRestarts(cond)
[01:28:08.179]                           for (restart in restarts) {
[01:28:08.179]                             name <- restart$name
[01:28:08.179]                             if (is.null(name)) 
[01:28:08.179]                               next
[01:28:08.179]                             if (!grepl(pattern, name)) 
[01:28:08.179]                               next
[01:28:08.179]                             invokeRestart(restart)
[01:28:08.179]                             muffled <- TRUE
[01:28:08.179]                             break
[01:28:08.179]                           }
[01:28:08.179]                         }
[01:28:08.179]                       }
[01:28:08.179]                       invisible(muffled)
[01:28:08.179]                     }
[01:28:08.179]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.179]                   }
[01:28:08.179]                 }
[01:28:08.179]             }
[01:28:08.179]         }))
[01:28:08.179]     }, error = function(ex) {
[01:28:08.179]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.179]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.179]                 ...future.rng), started = ...future.startTime, 
[01:28:08.179]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.179]             version = "1.8"), class = "FutureResult")
[01:28:08.179]     }, finally = {
[01:28:08.179]         if (!identical(...future.workdir, getwd())) 
[01:28:08.179]             setwd(...future.workdir)
[01:28:08.179]         {
[01:28:08.179]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.179]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.179]             }
[01:28:08.179]             base::options(...future.oldOptions)
[01:28:08.179]             if (.Platform$OS.type == "windows") {
[01:28:08.179]                 old_names <- names(...future.oldEnvVars)
[01:28:08.179]                 envs <- base::Sys.getenv()
[01:28:08.179]                 names <- names(envs)
[01:28:08.179]                 common <- intersect(names, old_names)
[01:28:08.179]                 added <- setdiff(names, old_names)
[01:28:08.179]                 removed <- setdiff(old_names, names)
[01:28:08.179]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.179]                   envs[common]]
[01:28:08.179]                 NAMES <- toupper(changed)
[01:28:08.179]                 args <- list()
[01:28:08.179]                 for (kk in seq_along(NAMES)) {
[01:28:08.179]                   name <- changed[[kk]]
[01:28:08.179]                   NAME <- NAMES[[kk]]
[01:28:08.179]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.179]                     next
[01:28:08.179]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.179]                 }
[01:28:08.179]                 NAMES <- toupper(added)
[01:28:08.179]                 for (kk in seq_along(NAMES)) {
[01:28:08.179]                   name <- added[[kk]]
[01:28:08.179]                   NAME <- NAMES[[kk]]
[01:28:08.179]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.179]                     next
[01:28:08.179]                   args[[name]] <- ""
[01:28:08.179]                 }
[01:28:08.179]                 NAMES <- toupper(removed)
[01:28:08.179]                 for (kk in seq_along(NAMES)) {
[01:28:08.179]                   name <- removed[[kk]]
[01:28:08.179]                   NAME <- NAMES[[kk]]
[01:28:08.179]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.179]                     next
[01:28:08.179]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.179]                 }
[01:28:08.179]                 if (length(args) > 0) 
[01:28:08.179]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.179]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.179]             }
[01:28:08.179]             else {
[01:28:08.179]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.179]             }
[01:28:08.179]             {
[01:28:08.179]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.179]                   0L) {
[01:28:08.179]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.179]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.179]                   base::options(opts)
[01:28:08.179]                 }
[01:28:08.179]                 {
[01:28:08.179]                   {
[01:28:08.179]                     NULL
[01:28:08.179]                     RNGkind("Mersenne-Twister")
[01:28:08.179]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.179]                       inherits = FALSE)
[01:28:08.179]                   }
[01:28:08.179]                   options(future.plan = NULL)
[01:28:08.179]                   if (is.na(NA_character_)) 
[01:28:08.179]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.179]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.179]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.179]                   {
[01:28:08.179]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.179]                     if (!future$lazy) 
[01:28:08.179]                       future <- run(future)
[01:28:08.179]                     invisible(future)
[01:28:08.179]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.179]                 }
[01:28:08.179]             }
[01:28:08.179]         }
[01:28:08.179]     })
[01:28:08.179]     if (TRUE) {
[01:28:08.179]         base::sink(type = "output", split = FALSE)
[01:28:08.179]         if (TRUE) {
[01:28:08.179]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.179]         }
[01:28:08.179]         else {
[01:28:08.179]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.179]         }
[01:28:08.179]         base::close(...future.stdout)
[01:28:08.179]         ...future.stdout <- NULL
[01:28:08.179]     }
[01:28:08.179]     ...future.result$conditions <- ...future.conditions
[01:28:08.179]     ...future.result$finished <- base::Sys.time()
[01:28:08.179]     ...future.result
[01:28:08.179] }
[01:28:08.182] assign_globals() ...
[01:28:08.183] List of 1
[01:28:08.183]  $ a: num 3
[01:28:08.183]  - attr(*, "where")=List of 1
[01:28:08.183]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.183]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.183]  - attr(*, "resolved")= logi TRUE
[01:28:08.183]  - attr(*, "total_size")= num 56
[01:28:08.183]  - attr(*, "already-done")= logi TRUE
[01:28:08.186] - copied 'a' to environment
[01:28:08.186] assign_globals() ... done
[01:28:08.186] plan(): Setting new future strategy stack:
[01:28:08.186] List of future strategies:
[01:28:08.186] 1. sequential:
[01:28:08.186]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.186]    - tweaked: FALSE
[01:28:08.186]    - call: NULL
[01:28:08.187] plan(): nbrOfWorkers() = 1
[01:28:08.188] plan(): Setting new future strategy stack:
[01:28:08.188] List of future strategies:
[01:28:08.188] 1. sequential:
[01:28:08.188]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.188]    - tweaked: FALSE
[01:28:08.188]    - call: plan(strategy)
[01:28:08.189] plan(): nbrOfWorkers() = 1
[01:28:08.189] SequentialFuture started (and completed)
[01:28:08.189] - Launch lazy future ... done
[01:28:08.189] run() for 'SequentialFuture' ... done
y = 6
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.190] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.191] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.193] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.193] Searching for globals ... DONE
[01:28:08.193] Resolving globals: TRUE
[01:28:08.193] Resolving any globals that are futures ...
[01:28:08.194] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.194] Resolving any globals that are futures ... DONE
[01:28:08.194] Resolving futures part of globals (recursively) ...
[01:28:08.195] resolve() on list ...
[01:28:08.195]  recursive: 99
[01:28:08.195]  length: 2
[01:28:08.195]  elements: 'a', 'ii'
[01:28:08.195]  length: 1 (resolved future 1)
[01:28:08.195]  length: 0 (resolved future 2)
[01:28:08.196] resolve() on list ... DONE
[01:28:08.196] - globals: [2] 'a', 'ii'
[01:28:08.196] Resolving futures part of globals (recursively) ... DONE
[01:28:08.196] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:08.197] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:08.197] - globals: [2] 'a', 'ii'
[01:28:08.197] 
[01:28:08.197] getGlobalsAndPackages() ... DONE
[01:28:08.198] run() for 'Future' ...
[01:28:08.198] - state: 'created'
[01:28:08.198] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.199] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.199] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.199]   - Field: 'label'
[01:28:08.199]   - Field: 'local'
[01:28:08.200]   - Field: 'owner'
[01:28:08.200]   - Field: 'envir'
[01:28:08.200]   - Field: 'packages'
[01:28:08.200]   - Field: 'gc'
[01:28:08.200]   - Field: 'conditions'
[01:28:08.201]   - Field: 'expr'
[01:28:08.201]   - Field: 'uuid'
[01:28:08.201]   - Field: 'seed'
[01:28:08.201]   - Field: 'version'
[01:28:08.201]   - Field: 'result'
[01:28:08.201]   - Field: 'asynchronous'
[01:28:08.202]   - Field: 'calls'
[01:28:08.202]   - Field: 'globals'
[01:28:08.203]   - Field: 'stdout'
[01:28:08.203]   - Field: 'earlySignal'
[01:28:08.204]   - Field: 'lazy'
[01:28:08.204]   - Field: 'state'
[01:28:08.204] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.204] - Launch lazy future ...
[01:28:08.204] Packages needed by the future expression (n = 0): <none>
[01:28:08.205] Packages needed by future strategies (n = 0): <none>
[01:28:08.205] {
[01:28:08.205]     {
[01:28:08.205]         {
[01:28:08.205]             ...future.startTime <- base::Sys.time()
[01:28:08.205]             {
[01:28:08.205]                 {
[01:28:08.205]                   {
[01:28:08.205]                     base::local({
[01:28:08.205]                       has_future <- base::requireNamespace("future", 
[01:28:08.205]                         quietly = TRUE)
[01:28:08.205]                       if (has_future) {
[01:28:08.205]                         ns <- base::getNamespace("future")
[01:28:08.205]                         version <- ns[[".package"]][["version"]]
[01:28:08.205]                         if (is.null(version)) 
[01:28:08.205]                           version <- utils::packageVersion("future")
[01:28:08.205]                       }
[01:28:08.205]                       else {
[01:28:08.205]                         version <- NULL
[01:28:08.205]                       }
[01:28:08.205]                       if (!has_future || version < "1.8.0") {
[01:28:08.205]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.205]                           "", base::R.version$version.string), 
[01:28:08.205]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.205]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.205]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.205]                             "release", "version")], collapse = " "), 
[01:28:08.205]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.205]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.205]                           info)
[01:28:08.205]                         info <- base::paste(info, collapse = "; ")
[01:28:08.205]                         if (!has_future) {
[01:28:08.205]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.205]                             info)
[01:28:08.205]                         }
[01:28:08.205]                         else {
[01:28:08.205]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.205]                             info, version)
[01:28:08.205]                         }
[01:28:08.205]                         base::stop(msg)
[01:28:08.205]                       }
[01:28:08.205]                     })
[01:28:08.205]                   }
[01:28:08.205]                   options(future.plan = NULL)
[01:28:08.205]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.205]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.205]                 }
[01:28:08.205]                 ...future.workdir <- getwd()
[01:28:08.205]             }
[01:28:08.205]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.205]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.205]         }
[01:28:08.205]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.205]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.205]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.205]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.205]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.205]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.205]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.205]             base::names(...future.oldOptions))
[01:28:08.205]     }
[01:28:08.205]     if (FALSE) {
[01:28:08.205]     }
[01:28:08.205]     else {
[01:28:08.205]         if (TRUE) {
[01:28:08.205]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.205]                 open = "w")
[01:28:08.205]         }
[01:28:08.205]         else {
[01:28:08.205]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.205]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.205]         }
[01:28:08.205]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.205]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.205]             base::sink(type = "output", split = FALSE)
[01:28:08.205]             base::close(...future.stdout)
[01:28:08.205]         }, add = TRUE)
[01:28:08.205]     }
[01:28:08.205]     ...future.frame <- base::sys.nframe()
[01:28:08.205]     ...future.conditions <- base::list()
[01:28:08.205]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.205]     if (FALSE) {
[01:28:08.205]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.205]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.205]     }
[01:28:08.205]     ...future.result <- base::tryCatch({
[01:28:08.205]         base::withCallingHandlers({
[01:28:08.205]             ...future.value <- base::withVisible(base::local({
[01:28:08.205]                 b <- a * ii
[01:28:08.205]                 a <- 0
[01:28:08.205]                 b
[01:28:08.205]             }))
[01:28:08.205]             future::FutureResult(value = ...future.value$value, 
[01:28:08.205]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.205]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.205]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.205]                     ...future.globalenv.names))
[01:28:08.205]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.205]         }, condition = base::local({
[01:28:08.205]             c <- base::c
[01:28:08.205]             inherits <- base::inherits
[01:28:08.205]             invokeRestart <- base::invokeRestart
[01:28:08.205]             length <- base::length
[01:28:08.205]             list <- base::list
[01:28:08.205]             seq.int <- base::seq.int
[01:28:08.205]             signalCondition <- base::signalCondition
[01:28:08.205]             sys.calls <- base::sys.calls
[01:28:08.205]             `[[` <- base::`[[`
[01:28:08.205]             `+` <- base::`+`
[01:28:08.205]             `<<-` <- base::`<<-`
[01:28:08.205]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.205]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.205]                   3L)]
[01:28:08.205]             }
[01:28:08.205]             function(cond) {
[01:28:08.205]                 is_error <- inherits(cond, "error")
[01:28:08.205]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.205]                   NULL)
[01:28:08.205]                 if (is_error) {
[01:28:08.205]                   sessionInformation <- function() {
[01:28:08.205]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.205]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.205]                       search = base::search(), system = base::Sys.info())
[01:28:08.205]                   }
[01:28:08.205]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.205]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.205]                     cond$call), session = sessionInformation(), 
[01:28:08.205]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.205]                   signalCondition(cond)
[01:28:08.205]                 }
[01:28:08.205]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.205]                 "immediateCondition"))) {
[01:28:08.205]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.205]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.205]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.205]                   if (TRUE && !signal) {
[01:28:08.205]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.205]                     {
[01:28:08.205]                       inherits <- base::inherits
[01:28:08.205]                       invokeRestart <- base::invokeRestart
[01:28:08.205]                       is.null <- base::is.null
[01:28:08.205]                       muffled <- FALSE
[01:28:08.205]                       if (inherits(cond, "message")) {
[01:28:08.205]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.205]                         if (muffled) 
[01:28:08.205]                           invokeRestart("muffleMessage")
[01:28:08.205]                       }
[01:28:08.205]                       else if (inherits(cond, "warning")) {
[01:28:08.205]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.205]                         if (muffled) 
[01:28:08.205]                           invokeRestart("muffleWarning")
[01:28:08.205]                       }
[01:28:08.205]                       else if (inherits(cond, "condition")) {
[01:28:08.205]                         if (!is.null(pattern)) {
[01:28:08.205]                           computeRestarts <- base::computeRestarts
[01:28:08.205]                           grepl <- base::grepl
[01:28:08.205]                           restarts <- computeRestarts(cond)
[01:28:08.205]                           for (restart in restarts) {
[01:28:08.205]                             name <- restart$name
[01:28:08.205]                             if (is.null(name)) 
[01:28:08.205]                               next
[01:28:08.205]                             if (!grepl(pattern, name)) 
[01:28:08.205]                               next
[01:28:08.205]                             invokeRestart(restart)
[01:28:08.205]                             muffled <- TRUE
[01:28:08.205]                             break
[01:28:08.205]                           }
[01:28:08.205]                         }
[01:28:08.205]                       }
[01:28:08.205]                       invisible(muffled)
[01:28:08.205]                     }
[01:28:08.205]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.205]                   }
[01:28:08.205]                 }
[01:28:08.205]                 else {
[01:28:08.205]                   if (TRUE) {
[01:28:08.205]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.205]                     {
[01:28:08.205]                       inherits <- base::inherits
[01:28:08.205]                       invokeRestart <- base::invokeRestart
[01:28:08.205]                       is.null <- base::is.null
[01:28:08.205]                       muffled <- FALSE
[01:28:08.205]                       if (inherits(cond, "message")) {
[01:28:08.205]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.205]                         if (muffled) 
[01:28:08.205]                           invokeRestart("muffleMessage")
[01:28:08.205]                       }
[01:28:08.205]                       else if (inherits(cond, "warning")) {
[01:28:08.205]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.205]                         if (muffled) 
[01:28:08.205]                           invokeRestart("muffleWarning")
[01:28:08.205]                       }
[01:28:08.205]                       else if (inherits(cond, "condition")) {
[01:28:08.205]                         if (!is.null(pattern)) {
[01:28:08.205]                           computeRestarts <- base::computeRestarts
[01:28:08.205]                           grepl <- base::grepl
[01:28:08.205]                           restarts <- computeRestarts(cond)
[01:28:08.205]                           for (restart in restarts) {
[01:28:08.205]                             name <- restart$name
[01:28:08.205]                             if (is.null(name)) 
[01:28:08.205]                               next
[01:28:08.205]                             if (!grepl(pattern, name)) 
[01:28:08.205]                               next
[01:28:08.205]                             invokeRestart(restart)
[01:28:08.205]                             muffled <- TRUE
[01:28:08.205]                             break
[01:28:08.205]                           }
[01:28:08.205]                         }
[01:28:08.205]                       }
[01:28:08.205]                       invisible(muffled)
[01:28:08.205]                     }
[01:28:08.205]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.205]                   }
[01:28:08.205]                 }
[01:28:08.205]             }
[01:28:08.205]         }))
[01:28:08.205]     }, error = function(ex) {
[01:28:08.205]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.205]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.205]                 ...future.rng), started = ...future.startTime, 
[01:28:08.205]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.205]             version = "1.8"), class = "FutureResult")
[01:28:08.205]     }, finally = {
[01:28:08.205]         if (!identical(...future.workdir, getwd())) 
[01:28:08.205]             setwd(...future.workdir)
[01:28:08.205]         {
[01:28:08.205]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.205]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.205]             }
[01:28:08.205]             base::options(...future.oldOptions)
[01:28:08.205]             if (.Platform$OS.type == "windows") {
[01:28:08.205]                 old_names <- names(...future.oldEnvVars)
[01:28:08.205]                 envs <- base::Sys.getenv()
[01:28:08.205]                 names <- names(envs)
[01:28:08.205]                 common <- intersect(names, old_names)
[01:28:08.205]                 added <- setdiff(names, old_names)
[01:28:08.205]                 removed <- setdiff(old_names, names)
[01:28:08.205]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.205]                   envs[common]]
[01:28:08.205]                 NAMES <- toupper(changed)
[01:28:08.205]                 args <- list()
[01:28:08.205]                 for (kk in seq_along(NAMES)) {
[01:28:08.205]                   name <- changed[[kk]]
[01:28:08.205]                   NAME <- NAMES[[kk]]
[01:28:08.205]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.205]                     next
[01:28:08.205]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.205]                 }
[01:28:08.205]                 NAMES <- toupper(added)
[01:28:08.205]                 for (kk in seq_along(NAMES)) {
[01:28:08.205]                   name <- added[[kk]]
[01:28:08.205]                   NAME <- NAMES[[kk]]
[01:28:08.205]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.205]                     next
[01:28:08.205]                   args[[name]] <- ""
[01:28:08.205]                 }
[01:28:08.205]                 NAMES <- toupper(removed)
[01:28:08.205]                 for (kk in seq_along(NAMES)) {
[01:28:08.205]                   name <- removed[[kk]]
[01:28:08.205]                   NAME <- NAMES[[kk]]
[01:28:08.205]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.205]                     next
[01:28:08.205]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.205]                 }
[01:28:08.205]                 if (length(args) > 0) 
[01:28:08.205]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.205]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.205]             }
[01:28:08.205]             else {
[01:28:08.205]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.205]             }
[01:28:08.205]             {
[01:28:08.205]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.205]                   0L) {
[01:28:08.205]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.205]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.205]                   base::options(opts)
[01:28:08.205]                 }
[01:28:08.205]                 {
[01:28:08.205]                   {
[01:28:08.205]                     NULL
[01:28:08.205]                     RNGkind("Mersenne-Twister")
[01:28:08.205]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.205]                       inherits = FALSE)
[01:28:08.205]                   }
[01:28:08.205]                   options(future.plan = NULL)
[01:28:08.205]                   if (is.na(NA_character_)) 
[01:28:08.205]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.205]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.205]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.205]                   {
[01:28:08.205]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.205]                     if (!future$lazy) 
[01:28:08.205]                       future <- run(future)
[01:28:08.205]                     invisible(future)
[01:28:08.205]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.205]                 }
[01:28:08.205]             }
[01:28:08.205]         }
[01:28:08.205]     })
[01:28:08.205]     if (TRUE) {
[01:28:08.205]         base::sink(type = "output", split = FALSE)
[01:28:08.205]         if (TRUE) {
[01:28:08.205]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.205]         }
[01:28:08.205]         else {
[01:28:08.205]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.205]         }
[01:28:08.205]         base::close(...future.stdout)
[01:28:08.205]         ...future.stdout <- NULL
[01:28:08.205]     }
[01:28:08.205]     ...future.result$conditions <- ...future.conditions
[01:28:08.205]     ...future.result$finished <- base::Sys.time()
[01:28:08.205]     ...future.result
[01:28:08.205] }
[01:28:08.209] assign_globals() ...
[01:28:08.209] List of 2
[01:28:08.209]  $ a : num 1
[01:28:08.209]  $ ii: int 1
[01:28:08.209]  - attr(*, "where")=List of 2
[01:28:08.209]   ..$ a :<environment: R_EmptyEnv> 
[01:28:08.209]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:08.209]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.209]  - attr(*, "resolved")= logi TRUE
[01:28:08.209]  - attr(*, "total_size")= num 112
[01:28:08.209]  - attr(*, "already-done")= logi TRUE
[01:28:08.212] - copied 'a' to environment
[01:28:08.213] - copied 'ii' to environment
[01:28:08.213] assign_globals() ... done
[01:28:08.213] plan(): Setting new future strategy stack:
[01:28:08.213] List of future strategies:
[01:28:08.213] 1. sequential:
[01:28:08.213]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.213]    - tweaked: FALSE
[01:28:08.213]    - call: NULL
[01:28:08.214] plan(): nbrOfWorkers() = 1
[01:28:08.215] plan(): Setting new future strategy stack:
[01:28:08.215] List of future strategies:
[01:28:08.215] 1. sequential:
[01:28:08.215]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.215]    - tweaked: FALSE
[01:28:08.215]    - call: plan(strategy)
[01:28:08.216] plan(): nbrOfWorkers() = 1
[01:28:08.216] SequentialFuture started (and completed)
[01:28:08.216] - Launch lazy future ... done
[01:28:08.217] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.217] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.218] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.220] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.220] Searching for globals ... DONE
[01:28:08.220] Resolving globals: TRUE
[01:28:08.220] Resolving any globals that are futures ...
[01:28:08.221] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.221] Resolving any globals that are futures ... DONE
[01:28:08.221] Resolving futures part of globals (recursively) ...
[01:28:08.221] resolve() on list ...
[01:28:08.222]  recursive: 99
[01:28:08.222]  length: 2
[01:28:08.222]  elements: 'a', 'ii'
[01:28:08.222]  length: 1 (resolved future 1)
[01:28:08.222]  length: 0 (resolved future 2)
[01:28:08.222] resolve() on list ... DONE
[01:28:08.223] - globals: [2] 'a', 'ii'
[01:28:08.223] Resolving futures part of globals (recursively) ... DONE
[01:28:08.223] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:08.224] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:08.224] - globals: [2] 'a', 'ii'
[01:28:08.224] 
[01:28:08.224] getGlobalsAndPackages() ... DONE
[01:28:08.224] run() for 'Future' ...
[01:28:08.225] - state: 'created'
[01:28:08.225] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.225] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.225] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.226]   - Field: 'label'
[01:28:08.226]   - Field: 'local'
[01:28:08.226]   - Field: 'owner'
[01:28:08.226]   - Field: 'envir'
[01:28:08.226]   - Field: 'packages'
[01:28:08.226]   - Field: 'gc'
[01:28:08.227]   - Field: 'conditions'
[01:28:08.227]   - Field: 'expr'
[01:28:08.227]   - Field: 'uuid'
[01:28:08.227]   - Field: 'seed'
[01:28:08.227]   - Field: 'version'
[01:28:08.227]   - Field: 'result'
[01:28:08.228]   - Field: 'asynchronous'
[01:28:08.228]   - Field: 'calls'
[01:28:08.228]   - Field: 'globals'
[01:28:08.228]   - Field: 'stdout'
[01:28:08.228]   - Field: 'earlySignal'
[01:28:08.228]   - Field: 'lazy'
[01:28:08.229]   - Field: 'state'
[01:28:08.229] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.229] - Launch lazy future ...
[01:28:08.229] Packages needed by the future expression (n = 0): <none>
[01:28:08.229] Packages needed by future strategies (n = 0): <none>
[01:28:08.230] {
[01:28:08.230]     {
[01:28:08.230]         {
[01:28:08.230]             ...future.startTime <- base::Sys.time()
[01:28:08.230]             {
[01:28:08.230]                 {
[01:28:08.230]                   {
[01:28:08.230]                     base::local({
[01:28:08.230]                       has_future <- base::requireNamespace("future", 
[01:28:08.230]                         quietly = TRUE)
[01:28:08.230]                       if (has_future) {
[01:28:08.230]                         ns <- base::getNamespace("future")
[01:28:08.230]                         version <- ns[[".package"]][["version"]]
[01:28:08.230]                         if (is.null(version)) 
[01:28:08.230]                           version <- utils::packageVersion("future")
[01:28:08.230]                       }
[01:28:08.230]                       else {
[01:28:08.230]                         version <- NULL
[01:28:08.230]                       }
[01:28:08.230]                       if (!has_future || version < "1.8.0") {
[01:28:08.230]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.230]                           "", base::R.version$version.string), 
[01:28:08.230]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.230]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.230]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.230]                             "release", "version")], collapse = " "), 
[01:28:08.230]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.230]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.230]                           info)
[01:28:08.230]                         info <- base::paste(info, collapse = "; ")
[01:28:08.230]                         if (!has_future) {
[01:28:08.230]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.230]                             info)
[01:28:08.230]                         }
[01:28:08.230]                         else {
[01:28:08.230]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.230]                             info, version)
[01:28:08.230]                         }
[01:28:08.230]                         base::stop(msg)
[01:28:08.230]                       }
[01:28:08.230]                     })
[01:28:08.230]                   }
[01:28:08.230]                   options(future.plan = NULL)
[01:28:08.230]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.230]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.230]                 }
[01:28:08.230]                 ...future.workdir <- getwd()
[01:28:08.230]             }
[01:28:08.230]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.230]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.230]         }
[01:28:08.230]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.230]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.230]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.230]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.230]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.230]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.230]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.230]             base::names(...future.oldOptions))
[01:28:08.230]     }
[01:28:08.230]     if (FALSE) {
[01:28:08.230]     }
[01:28:08.230]     else {
[01:28:08.230]         if (TRUE) {
[01:28:08.230]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.230]                 open = "w")
[01:28:08.230]         }
[01:28:08.230]         else {
[01:28:08.230]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.230]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.230]         }
[01:28:08.230]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.230]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.230]             base::sink(type = "output", split = FALSE)
[01:28:08.230]             base::close(...future.stdout)
[01:28:08.230]         }, add = TRUE)
[01:28:08.230]     }
[01:28:08.230]     ...future.frame <- base::sys.nframe()
[01:28:08.230]     ...future.conditions <- base::list()
[01:28:08.230]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.230]     if (FALSE) {
[01:28:08.230]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.230]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.230]     }
[01:28:08.230]     ...future.result <- base::tryCatch({
[01:28:08.230]         base::withCallingHandlers({
[01:28:08.230]             ...future.value <- base::withVisible(base::local({
[01:28:08.230]                 b <- a * ii
[01:28:08.230]                 a <- 0
[01:28:08.230]                 b
[01:28:08.230]             }))
[01:28:08.230]             future::FutureResult(value = ...future.value$value, 
[01:28:08.230]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.230]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.230]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.230]                     ...future.globalenv.names))
[01:28:08.230]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.230]         }, condition = base::local({
[01:28:08.230]             c <- base::c
[01:28:08.230]             inherits <- base::inherits
[01:28:08.230]             invokeRestart <- base::invokeRestart
[01:28:08.230]             length <- base::length
[01:28:08.230]             list <- base::list
[01:28:08.230]             seq.int <- base::seq.int
[01:28:08.230]             signalCondition <- base::signalCondition
[01:28:08.230]             sys.calls <- base::sys.calls
[01:28:08.230]             `[[` <- base::`[[`
[01:28:08.230]             `+` <- base::`+`
[01:28:08.230]             `<<-` <- base::`<<-`
[01:28:08.230]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.230]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.230]                   3L)]
[01:28:08.230]             }
[01:28:08.230]             function(cond) {
[01:28:08.230]                 is_error <- inherits(cond, "error")
[01:28:08.230]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.230]                   NULL)
[01:28:08.230]                 if (is_error) {
[01:28:08.230]                   sessionInformation <- function() {
[01:28:08.230]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.230]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.230]                       search = base::search(), system = base::Sys.info())
[01:28:08.230]                   }
[01:28:08.230]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.230]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.230]                     cond$call), session = sessionInformation(), 
[01:28:08.230]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.230]                   signalCondition(cond)
[01:28:08.230]                 }
[01:28:08.230]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.230]                 "immediateCondition"))) {
[01:28:08.230]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.230]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.230]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.230]                   if (TRUE && !signal) {
[01:28:08.230]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.230]                     {
[01:28:08.230]                       inherits <- base::inherits
[01:28:08.230]                       invokeRestart <- base::invokeRestart
[01:28:08.230]                       is.null <- base::is.null
[01:28:08.230]                       muffled <- FALSE
[01:28:08.230]                       if (inherits(cond, "message")) {
[01:28:08.230]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.230]                         if (muffled) 
[01:28:08.230]                           invokeRestart("muffleMessage")
[01:28:08.230]                       }
[01:28:08.230]                       else if (inherits(cond, "warning")) {
[01:28:08.230]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.230]                         if (muffled) 
[01:28:08.230]                           invokeRestart("muffleWarning")
[01:28:08.230]                       }
[01:28:08.230]                       else if (inherits(cond, "condition")) {
[01:28:08.230]                         if (!is.null(pattern)) {
[01:28:08.230]                           computeRestarts <- base::computeRestarts
[01:28:08.230]                           grepl <- base::grepl
[01:28:08.230]                           restarts <- computeRestarts(cond)
[01:28:08.230]                           for (restart in restarts) {
[01:28:08.230]                             name <- restart$name
[01:28:08.230]                             if (is.null(name)) 
[01:28:08.230]                               next
[01:28:08.230]                             if (!grepl(pattern, name)) 
[01:28:08.230]                               next
[01:28:08.230]                             invokeRestart(restart)
[01:28:08.230]                             muffled <- TRUE
[01:28:08.230]                             break
[01:28:08.230]                           }
[01:28:08.230]                         }
[01:28:08.230]                       }
[01:28:08.230]                       invisible(muffled)
[01:28:08.230]                     }
[01:28:08.230]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.230]                   }
[01:28:08.230]                 }
[01:28:08.230]                 else {
[01:28:08.230]                   if (TRUE) {
[01:28:08.230]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.230]                     {
[01:28:08.230]                       inherits <- base::inherits
[01:28:08.230]                       invokeRestart <- base::invokeRestart
[01:28:08.230]                       is.null <- base::is.null
[01:28:08.230]                       muffled <- FALSE
[01:28:08.230]                       if (inherits(cond, "message")) {
[01:28:08.230]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.230]                         if (muffled) 
[01:28:08.230]                           invokeRestart("muffleMessage")
[01:28:08.230]                       }
[01:28:08.230]                       else if (inherits(cond, "warning")) {
[01:28:08.230]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.230]                         if (muffled) 
[01:28:08.230]                           invokeRestart("muffleWarning")
[01:28:08.230]                       }
[01:28:08.230]                       else if (inherits(cond, "condition")) {
[01:28:08.230]                         if (!is.null(pattern)) {
[01:28:08.230]                           computeRestarts <- base::computeRestarts
[01:28:08.230]                           grepl <- base::grepl
[01:28:08.230]                           restarts <- computeRestarts(cond)
[01:28:08.230]                           for (restart in restarts) {
[01:28:08.230]                             name <- restart$name
[01:28:08.230]                             if (is.null(name)) 
[01:28:08.230]                               next
[01:28:08.230]                             if (!grepl(pattern, name)) 
[01:28:08.230]                               next
[01:28:08.230]                             invokeRestart(restart)
[01:28:08.230]                             muffled <- TRUE
[01:28:08.230]                             break
[01:28:08.230]                           }
[01:28:08.230]                         }
[01:28:08.230]                       }
[01:28:08.230]                       invisible(muffled)
[01:28:08.230]                     }
[01:28:08.230]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.230]                   }
[01:28:08.230]                 }
[01:28:08.230]             }
[01:28:08.230]         }))
[01:28:08.230]     }, error = function(ex) {
[01:28:08.230]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.230]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.230]                 ...future.rng), started = ...future.startTime, 
[01:28:08.230]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.230]             version = "1.8"), class = "FutureResult")
[01:28:08.230]     }, finally = {
[01:28:08.230]         if (!identical(...future.workdir, getwd())) 
[01:28:08.230]             setwd(...future.workdir)
[01:28:08.230]         {
[01:28:08.230]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.230]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.230]             }
[01:28:08.230]             base::options(...future.oldOptions)
[01:28:08.230]             if (.Platform$OS.type == "windows") {
[01:28:08.230]                 old_names <- names(...future.oldEnvVars)
[01:28:08.230]                 envs <- base::Sys.getenv()
[01:28:08.230]                 names <- names(envs)
[01:28:08.230]                 common <- intersect(names, old_names)
[01:28:08.230]                 added <- setdiff(names, old_names)
[01:28:08.230]                 removed <- setdiff(old_names, names)
[01:28:08.230]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.230]                   envs[common]]
[01:28:08.230]                 NAMES <- toupper(changed)
[01:28:08.230]                 args <- list()
[01:28:08.230]                 for (kk in seq_along(NAMES)) {
[01:28:08.230]                   name <- changed[[kk]]
[01:28:08.230]                   NAME <- NAMES[[kk]]
[01:28:08.230]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.230]                     next
[01:28:08.230]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.230]                 }
[01:28:08.230]                 NAMES <- toupper(added)
[01:28:08.230]                 for (kk in seq_along(NAMES)) {
[01:28:08.230]                   name <- added[[kk]]
[01:28:08.230]                   NAME <- NAMES[[kk]]
[01:28:08.230]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.230]                     next
[01:28:08.230]                   args[[name]] <- ""
[01:28:08.230]                 }
[01:28:08.230]                 NAMES <- toupper(removed)
[01:28:08.230]                 for (kk in seq_along(NAMES)) {
[01:28:08.230]                   name <- removed[[kk]]
[01:28:08.230]                   NAME <- NAMES[[kk]]
[01:28:08.230]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.230]                     next
[01:28:08.230]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.230]                 }
[01:28:08.230]                 if (length(args) > 0) 
[01:28:08.230]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.230]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.230]             }
[01:28:08.230]             else {
[01:28:08.230]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.230]             }
[01:28:08.230]             {
[01:28:08.230]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.230]                   0L) {
[01:28:08.230]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.230]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.230]                   base::options(opts)
[01:28:08.230]                 }
[01:28:08.230]                 {
[01:28:08.230]                   {
[01:28:08.230]                     NULL
[01:28:08.230]                     RNGkind("Mersenne-Twister")
[01:28:08.230]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.230]                       inherits = FALSE)
[01:28:08.230]                   }
[01:28:08.230]                   options(future.plan = NULL)
[01:28:08.230]                   if (is.na(NA_character_)) 
[01:28:08.230]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.230]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.230]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.230]                   {
[01:28:08.230]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.230]                     if (!future$lazy) 
[01:28:08.230]                       future <- run(future)
[01:28:08.230]                     invisible(future)
[01:28:08.230]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.230]                 }
[01:28:08.230]             }
[01:28:08.230]         }
[01:28:08.230]     })
[01:28:08.230]     if (TRUE) {
[01:28:08.230]         base::sink(type = "output", split = FALSE)
[01:28:08.230]         if (TRUE) {
[01:28:08.230]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.230]         }
[01:28:08.230]         else {
[01:28:08.230]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.230]         }
[01:28:08.230]         base::close(...future.stdout)
[01:28:08.230]         ...future.stdout <- NULL
[01:28:08.230]     }
[01:28:08.230]     ...future.result$conditions <- ...future.conditions
[01:28:08.230]     ...future.result$finished <- base::Sys.time()
[01:28:08.230]     ...future.result
[01:28:08.230] }
[01:28:08.234] assign_globals() ...
[01:28:08.234] List of 2
[01:28:08.234]  $ a : num 1
[01:28:08.234]  $ ii: int 2
[01:28:08.234]  - attr(*, "where")=List of 2
[01:28:08.234]   ..$ a :<environment: R_EmptyEnv> 
[01:28:08.234]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:08.234]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.234]  - attr(*, "resolved")= logi TRUE
[01:28:08.234]  - attr(*, "total_size")= num 112
[01:28:08.234]  - attr(*, "already-done")= logi TRUE
[01:28:08.264] - copied 'a' to environment
[01:28:08.264] - copied 'ii' to environment
[01:28:08.264] assign_globals() ... done
[01:28:08.265] plan(): Setting new future strategy stack:
[01:28:08.265] List of future strategies:
[01:28:08.265] 1. sequential:
[01:28:08.265]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.265]    - tweaked: FALSE
[01:28:08.265]    - call: NULL
[01:28:08.265] plan(): nbrOfWorkers() = 1
[01:28:08.266] plan(): Setting new future strategy stack:
[01:28:08.267] List of future strategies:
[01:28:08.267] 1. sequential:
[01:28:08.267]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.267]    - tweaked: FALSE
[01:28:08.267]    - call: plan(strategy)
[01:28:08.267] plan(): nbrOfWorkers() = 1
[01:28:08.268] SequentialFuture started (and completed)
[01:28:08.268] - Launch lazy future ... done
[01:28:08.268] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.269] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.269] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.271] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.271] Searching for globals ... DONE
[01:28:08.272] Resolving globals: TRUE
[01:28:08.272] Resolving any globals that are futures ...
[01:28:08.272] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.272] Resolving any globals that are futures ... DONE
[01:28:08.273] Resolving futures part of globals (recursively) ...
[01:28:08.273] resolve() on list ...
[01:28:08.273]  recursive: 99
[01:28:08.273]  length: 2
[01:28:08.273]  elements: 'a', 'ii'
[01:28:08.274]  length: 1 (resolved future 1)
[01:28:08.274]  length: 0 (resolved future 2)
[01:28:08.274] resolve() on list ... DONE
[01:28:08.274] - globals: [2] 'a', 'ii'
[01:28:08.274] Resolving futures part of globals (recursively) ... DONE
[01:28:08.275] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:08.275] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:08.275] - globals: [2] 'a', 'ii'
[01:28:08.276] 
[01:28:08.276] getGlobalsAndPackages() ... DONE
[01:28:08.276] run() for 'Future' ...
[01:28:08.276] - state: 'created'
[01:28:08.276] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.277] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.277] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.277]   - Field: 'label'
[01:28:08.277]   - Field: 'local'
[01:28:08.278]   - Field: 'owner'
[01:28:08.278]   - Field: 'envir'
[01:28:08.278]   - Field: 'packages'
[01:28:08.278]   - Field: 'gc'
[01:28:08.278]   - Field: 'conditions'
[01:28:08.278]   - Field: 'expr'
[01:28:08.279]   - Field: 'uuid'
[01:28:08.279]   - Field: 'seed'
[01:28:08.279]   - Field: 'version'
[01:28:08.279]   - Field: 'result'
[01:28:08.279]   - Field: 'asynchronous'
[01:28:08.280]   - Field: 'calls'
[01:28:08.280]   - Field: 'globals'
[01:28:08.280]   - Field: 'stdout'
[01:28:08.280]   - Field: 'earlySignal'
[01:28:08.280]   - Field: 'lazy'
[01:28:08.280]   - Field: 'state'
[01:28:08.281] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.281] - Launch lazy future ...
[01:28:08.281] Packages needed by the future expression (n = 0): <none>
[01:28:08.281] Packages needed by future strategies (n = 0): <none>
[01:28:08.282] {
[01:28:08.282]     {
[01:28:08.282]         {
[01:28:08.282]             ...future.startTime <- base::Sys.time()
[01:28:08.282]             {
[01:28:08.282]                 {
[01:28:08.282]                   {
[01:28:08.282]                     base::local({
[01:28:08.282]                       has_future <- base::requireNamespace("future", 
[01:28:08.282]                         quietly = TRUE)
[01:28:08.282]                       if (has_future) {
[01:28:08.282]                         ns <- base::getNamespace("future")
[01:28:08.282]                         version <- ns[[".package"]][["version"]]
[01:28:08.282]                         if (is.null(version)) 
[01:28:08.282]                           version <- utils::packageVersion("future")
[01:28:08.282]                       }
[01:28:08.282]                       else {
[01:28:08.282]                         version <- NULL
[01:28:08.282]                       }
[01:28:08.282]                       if (!has_future || version < "1.8.0") {
[01:28:08.282]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.282]                           "", base::R.version$version.string), 
[01:28:08.282]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.282]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.282]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.282]                             "release", "version")], collapse = " "), 
[01:28:08.282]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.282]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.282]                           info)
[01:28:08.282]                         info <- base::paste(info, collapse = "; ")
[01:28:08.282]                         if (!has_future) {
[01:28:08.282]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.282]                             info)
[01:28:08.282]                         }
[01:28:08.282]                         else {
[01:28:08.282]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.282]                             info, version)
[01:28:08.282]                         }
[01:28:08.282]                         base::stop(msg)
[01:28:08.282]                       }
[01:28:08.282]                     })
[01:28:08.282]                   }
[01:28:08.282]                   options(future.plan = NULL)
[01:28:08.282]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.282]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.282]                 }
[01:28:08.282]                 ...future.workdir <- getwd()
[01:28:08.282]             }
[01:28:08.282]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.282]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.282]         }
[01:28:08.282]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.282]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.282]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.282]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.282]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.282]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.282]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.282]             base::names(...future.oldOptions))
[01:28:08.282]     }
[01:28:08.282]     if (FALSE) {
[01:28:08.282]     }
[01:28:08.282]     else {
[01:28:08.282]         if (TRUE) {
[01:28:08.282]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.282]                 open = "w")
[01:28:08.282]         }
[01:28:08.282]         else {
[01:28:08.282]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.282]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.282]         }
[01:28:08.282]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.282]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.282]             base::sink(type = "output", split = FALSE)
[01:28:08.282]             base::close(...future.stdout)
[01:28:08.282]         }, add = TRUE)
[01:28:08.282]     }
[01:28:08.282]     ...future.frame <- base::sys.nframe()
[01:28:08.282]     ...future.conditions <- base::list()
[01:28:08.282]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.282]     if (FALSE) {
[01:28:08.282]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.282]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.282]     }
[01:28:08.282]     ...future.result <- base::tryCatch({
[01:28:08.282]         base::withCallingHandlers({
[01:28:08.282]             ...future.value <- base::withVisible(base::local({
[01:28:08.282]                 b <- a * ii
[01:28:08.282]                 a <- 0
[01:28:08.282]                 b
[01:28:08.282]             }))
[01:28:08.282]             future::FutureResult(value = ...future.value$value, 
[01:28:08.282]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.282]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.282]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.282]                     ...future.globalenv.names))
[01:28:08.282]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.282]         }, condition = base::local({
[01:28:08.282]             c <- base::c
[01:28:08.282]             inherits <- base::inherits
[01:28:08.282]             invokeRestart <- base::invokeRestart
[01:28:08.282]             length <- base::length
[01:28:08.282]             list <- base::list
[01:28:08.282]             seq.int <- base::seq.int
[01:28:08.282]             signalCondition <- base::signalCondition
[01:28:08.282]             sys.calls <- base::sys.calls
[01:28:08.282]             `[[` <- base::`[[`
[01:28:08.282]             `+` <- base::`+`
[01:28:08.282]             `<<-` <- base::`<<-`
[01:28:08.282]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.282]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.282]                   3L)]
[01:28:08.282]             }
[01:28:08.282]             function(cond) {
[01:28:08.282]                 is_error <- inherits(cond, "error")
[01:28:08.282]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.282]                   NULL)
[01:28:08.282]                 if (is_error) {
[01:28:08.282]                   sessionInformation <- function() {
[01:28:08.282]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.282]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.282]                       search = base::search(), system = base::Sys.info())
[01:28:08.282]                   }
[01:28:08.282]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.282]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.282]                     cond$call), session = sessionInformation(), 
[01:28:08.282]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.282]                   signalCondition(cond)
[01:28:08.282]                 }
[01:28:08.282]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.282]                 "immediateCondition"))) {
[01:28:08.282]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.282]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.282]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.282]                   if (TRUE && !signal) {
[01:28:08.282]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.282]                     {
[01:28:08.282]                       inherits <- base::inherits
[01:28:08.282]                       invokeRestart <- base::invokeRestart
[01:28:08.282]                       is.null <- base::is.null
[01:28:08.282]                       muffled <- FALSE
[01:28:08.282]                       if (inherits(cond, "message")) {
[01:28:08.282]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.282]                         if (muffled) 
[01:28:08.282]                           invokeRestart("muffleMessage")
[01:28:08.282]                       }
[01:28:08.282]                       else if (inherits(cond, "warning")) {
[01:28:08.282]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.282]                         if (muffled) 
[01:28:08.282]                           invokeRestart("muffleWarning")
[01:28:08.282]                       }
[01:28:08.282]                       else if (inherits(cond, "condition")) {
[01:28:08.282]                         if (!is.null(pattern)) {
[01:28:08.282]                           computeRestarts <- base::computeRestarts
[01:28:08.282]                           grepl <- base::grepl
[01:28:08.282]                           restarts <- computeRestarts(cond)
[01:28:08.282]                           for (restart in restarts) {
[01:28:08.282]                             name <- restart$name
[01:28:08.282]                             if (is.null(name)) 
[01:28:08.282]                               next
[01:28:08.282]                             if (!grepl(pattern, name)) 
[01:28:08.282]                               next
[01:28:08.282]                             invokeRestart(restart)
[01:28:08.282]                             muffled <- TRUE
[01:28:08.282]                             break
[01:28:08.282]                           }
[01:28:08.282]                         }
[01:28:08.282]                       }
[01:28:08.282]                       invisible(muffled)
[01:28:08.282]                     }
[01:28:08.282]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.282]                   }
[01:28:08.282]                 }
[01:28:08.282]                 else {
[01:28:08.282]                   if (TRUE) {
[01:28:08.282]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.282]                     {
[01:28:08.282]                       inherits <- base::inherits
[01:28:08.282]                       invokeRestart <- base::invokeRestart
[01:28:08.282]                       is.null <- base::is.null
[01:28:08.282]                       muffled <- FALSE
[01:28:08.282]                       if (inherits(cond, "message")) {
[01:28:08.282]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.282]                         if (muffled) 
[01:28:08.282]                           invokeRestart("muffleMessage")
[01:28:08.282]                       }
[01:28:08.282]                       else if (inherits(cond, "warning")) {
[01:28:08.282]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.282]                         if (muffled) 
[01:28:08.282]                           invokeRestart("muffleWarning")
[01:28:08.282]                       }
[01:28:08.282]                       else if (inherits(cond, "condition")) {
[01:28:08.282]                         if (!is.null(pattern)) {
[01:28:08.282]                           computeRestarts <- base::computeRestarts
[01:28:08.282]                           grepl <- base::grepl
[01:28:08.282]                           restarts <- computeRestarts(cond)
[01:28:08.282]                           for (restart in restarts) {
[01:28:08.282]                             name <- restart$name
[01:28:08.282]                             if (is.null(name)) 
[01:28:08.282]                               next
[01:28:08.282]                             if (!grepl(pattern, name)) 
[01:28:08.282]                               next
[01:28:08.282]                             invokeRestart(restart)
[01:28:08.282]                             muffled <- TRUE
[01:28:08.282]                             break
[01:28:08.282]                           }
[01:28:08.282]                         }
[01:28:08.282]                       }
[01:28:08.282]                       invisible(muffled)
[01:28:08.282]                     }
[01:28:08.282]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.282]                   }
[01:28:08.282]                 }
[01:28:08.282]             }
[01:28:08.282]         }))
[01:28:08.282]     }, error = function(ex) {
[01:28:08.282]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.282]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.282]                 ...future.rng), started = ...future.startTime, 
[01:28:08.282]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.282]             version = "1.8"), class = "FutureResult")
[01:28:08.282]     }, finally = {
[01:28:08.282]         if (!identical(...future.workdir, getwd())) 
[01:28:08.282]             setwd(...future.workdir)
[01:28:08.282]         {
[01:28:08.282]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.282]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.282]             }
[01:28:08.282]             base::options(...future.oldOptions)
[01:28:08.282]             if (.Platform$OS.type == "windows") {
[01:28:08.282]                 old_names <- names(...future.oldEnvVars)
[01:28:08.282]                 envs <- base::Sys.getenv()
[01:28:08.282]                 names <- names(envs)
[01:28:08.282]                 common <- intersect(names, old_names)
[01:28:08.282]                 added <- setdiff(names, old_names)
[01:28:08.282]                 removed <- setdiff(old_names, names)
[01:28:08.282]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.282]                   envs[common]]
[01:28:08.282]                 NAMES <- toupper(changed)
[01:28:08.282]                 args <- list()
[01:28:08.282]                 for (kk in seq_along(NAMES)) {
[01:28:08.282]                   name <- changed[[kk]]
[01:28:08.282]                   NAME <- NAMES[[kk]]
[01:28:08.282]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.282]                     next
[01:28:08.282]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.282]                 }
[01:28:08.282]                 NAMES <- toupper(added)
[01:28:08.282]                 for (kk in seq_along(NAMES)) {
[01:28:08.282]                   name <- added[[kk]]
[01:28:08.282]                   NAME <- NAMES[[kk]]
[01:28:08.282]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.282]                     next
[01:28:08.282]                   args[[name]] <- ""
[01:28:08.282]                 }
[01:28:08.282]                 NAMES <- toupper(removed)
[01:28:08.282]                 for (kk in seq_along(NAMES)) {
[01:28:08.282]                   name <- removed[[kk]]
[01:28:08.282]                   NAME <- NAMES[[kk]]
[01:28:08.282]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.282]                     next
[01:28:08.282]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.282]                 }
[01:28:08.282]                 if (length(args) > 0) 
[01:28:08.282]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.282]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.282]             }
[01:28:08.282]             else {
[01:28:08.282]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.282]             }
[01:28:08.282]             {
[01:28:08.282]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.282]                   0L) {
[01:28:08.282]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.282]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.282]                   base::options(opts)
[01:28:08.282]                 }
[01:28:08.282]                 {
[01:28:08.282]                   {
[01:28:08.282]                     NULL
[01:28:08.282]                     RNGkind("Mersenne-Twister")
[01:28:08.282]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.282]                       inherits = FALSE)
[01:28:08.282]                   }
[01:28:08.282]                   options(future.plan = NULL)
[01:28:08.282]                   if (is.na(NA_character_)) 
[01:28:08.282]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.282]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.282]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.282]                   {
[01:28:08.282]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.282]                     if (!future$lazy) 
[01:28:08.282]                       future <- run(future)
[01:28:08.282]                     invisible(future)
[01:28:08.282]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.282]                 }
[01:28:08.282]             }
[01:28:08.282]         }
[01:28:08.282]     })
[01:28:08.282]     if (TRUE) {
[01:28:08.282]         base::sink(type = "output", split = FALSE)
[01:28:08.282]         if (TRUE) {
[01:28:08.282]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.282]         }
[01:28:08.282]         else {
[01:28:08.282]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.282]         }
[01:28:08.282]         base::close(...future.stdout)
[01:28:08.282]         ...future.stdout <- NULL
[01:28:08.282]     }
[01:28:08.282]     ...future.result$conditions <- ...future.conditions
[01:28:08.282]     ...future.result$finished <- base::Sys.time()
[01:28:08.282]     ...future.result
[01:28:08.282] }
[01:28:08.285] assign_globals() ...
[01:28:08.286] List of 2
[01:28:08.286]  $ a : num 1
[01:28:08.286]  $ ii: int 3
[01:28:08.286]  - attr(*, "where")=List of 2
[01:28:08.286]   ..$ a :<environment: R_EmptyEnv> 
[01:28:08.286]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:08.286]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.286]  - attr(*, "resolved")= logi TRUE
[01:28:08.286]  - attr(*, "total_size")= num 112
[01:28:08.286]  - attr(*, "already-done")= logi TRUE
[01:28:08.289] - copied 'a' to environment
[01:28:08.289] - copied 'ii' to environment
[01:28:08.290] assign_globals() ... done
[01:28:08.290] plan(): Setting new future strategy stack:
[01:28:08.290] List of future strategies:
[01:28:08.290] 1. sequential:
[01:28:08.290]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.290]    - tweaked: FALSE
[01:28:08.290]    - call: NULL
[01:28:08.291] plan(): nbrOfWorkers() = 1
[01:28:08.292] plan(): Setting new future strategy stack:
[01:28:08.292] List of future strategies:
[01:28:08.292] 1. sequential:
[01:28:08.292]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.292]    - tweaked: FALSE
[01:28:08.292]    - call: plan(strategy)
[01:28:08.293] plan(): nbrOfWorkers() = 1
[01:28:08.294] SequentialFuture started (and completed)
[01:28:08.294] - Launch lazy future ... done
[01:28:08.294] run() for 'SequentialFuture' ... done
[1] 1 2 3
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.295] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.295] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.298] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.298] Searching for globals ... DONE
[01:28:08.298] Resolving globals: TRUE
[01:28:08.298] Resolving any globals that are futures ...
[01:28:08.299] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.299] Resolving any globals that are futures ... DONE
[01:28:08.299] Resolving futures part of globals (recursively) ...
[01:28:08.300] resolve() on list ...
[01:28:08.300]  recursive: 99
[01:28:08.300]  length: 2
[01:28:08.300]  elements: 'a', 'ii'
[01:28:08.300]  length: 1 (resolved future 1)
[01:28:08.300]  length: 0 (resolved future 2)
[01:28:08.301] resolve() on list ... DONE
[01:28:08.301] - globals: [2] 'a', 'ii'
[01:28:08.301] Resolving futures part of globals (recursively) ... DONE
[01:28:08.301] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:08.302] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:08.302] - globals: [2] 'a', 'ii'
[01:28:08.302] 
[01:28:08.302] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.303] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.303] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.305] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.306] Searching for globals ... DONE
[01:28:08.306] Resolving globals: TRUE
[01:28:08.306] Resolving any globals that are futures ...
[01:28:08.306] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.306] Resolving any globals that are futures ... DONE
[01:28:08.307] Resolving futures part of globals (recursively) ...
[01:28:08.307] resolve() on list ...
[01:28:08.307]  recursive: 99
[01:28:08.308]  length: 2
[01:28:08.308]  elements: 'a', 'ii'
[01:28:08.308]  length: 1 (resolved future 1)
[01:28:08.308]  length: 0 (resolved future 2)
[01:28:08.308] resolve() on list ... DONE
[01:28:08.308] - globals: [2] 'a', 'ii'
[01:28:08.309] Resolving futures part of globals (recursively) ... DONE
[01:28:08.309] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:08.309] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:08.310] - globals: [2] 'a', 'ii'
[01:28:08.310] 
[01:28:08.310] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.311] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.311] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.313] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.313] Searching for globals ... DONE
[01:28:08.314] Resolving globals: TRUE
[01:28:08.314] Resolving any globals that are futures ...
[01:28:08.314] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:08.314] Resolving any globals that are futures ... DONE
[01:28:08.315] Resolving futures part of globals (recursively) ...
[01:28:08.315] resolve() on list ...
[01:28:08.315]  recursive: 99
[01:28:08.315]  length: 2
[01:28:08.315]  elements: 'a', 'ii'
[01:28:08.316]  length: 1 (resolved future 1)
[01:28:08.316]  length: 0 (resolved future 2)
[01:28:08.316] resolve() on list ... DONE
[01:28:08.316] - globals: [2] 'a', 'ii'
[01:28:08.316] Resolving futures part of globals (recursively) ... DONE
[01:28:08.316] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:08.317] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:08.317] - globals: [2] 'a', 'ii'
[01:28:08.317] 
[01:28:08.317] getGlobalsAndPackages() ... DONE
[01:28:08.318] run() for 'Future' ...
[01:28:08.318] - state: 'created'
[01:28:08.318] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.319] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.319] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.319]   - Field: 'label'
[01:28:08.319]   - Field: 'local'
[01:28:08.319]   - Field: 'owner'
[01:28:08.320]   - Field: 'envir'
[01:28:08.320]   - Field: 'packages'
[01:28:08.320]   - Field: 'gc'
[01:28:08.321]   - Field: 'conditions'
[01:28:08.321]   - Field: 'expr'
[01:28:08.321]   - Field: 'uuid'
[01:28:08.321]   - Field: 'seed'
[01:28:08.321]   - Field: 'version'
[01:28:08.322]   - Field: 'result'
[01:28:08.322]   - Field: 'asynchronous'
[01:28:08.322]   - Field: 'calls'
[01:28:08.322]   - Field: 'globals'
[01:28:08.322]   - Field: 'stdout'
[01:28:08.323]   - Field: 'earlySignal'
[01:28:08.323]   - Field: 'lazy'
[01:28:08.323]   - Field: 'state'
[01:28:08.323] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.323] - Launch lazy future ...
[01:28:08.324] Packages needed by the future expression (n = 0): <none>
[01:28:08.324] Packages needed by future strategies (n = 0): <none>
[01:28:08.324] {
[01:28:08.324]     {
[01:28:08.324]         {
[01:28:08.324]             ...future.startTime <- base::Sys.time()
[01:28:08.324]             {
[01:28:08.324]                 {
[01:28:08.324]                   {
[01:28:08.324]                     base::local({
[01:28:08.324]                       has_future <- base::requireNamespace("future", 
[01:28:08.324]                         quietly = TRUE)
[01:28:08.324]                       if (has_future) {
[01:28:08.324]                         ns <- base::getNamespace("future")
[01:28:08.324]                         version <- ns[[".package"]][["version"]]
[01:28:08.324]                         if (is.null(version)) 
[01:28:08.324]                           version <- utils::packageVersion("future")
[01:28:08.324]                       }
[01:28:08.324]                       else {
[01:28:08.324]                         version <- NULL
[01:28:08.324]                       }
[01:28:08.324]                       if (!has_future || version < "1.8.0") {
[01:28:08.324]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.324]                           "", base::R.version$version.string), 
[01:28:08.324]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.324]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.324]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.324]                             "release", "version")], collapse = " "), 
[01:28:08.324]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.324]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.324]                           info)
[01:28:08.324]                         info <- base::paste(info, collapse = "; ")
[01:28:08.324]                         if (!has_future) {
[01:28:08.324]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.324]                             info)
[01:28:08.324]                         }
[01:28:08.324]                         else {
[01:28:08.324]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.324]                             info, version)
[01:28:08.324]                         }
[01:28:08.324]                         base::stop(msg)
[01:28:08.324]                       }
[01:28:08.324]                     })
[01:28:08.324]                   }
[01:28:08.324]                   options(future.plan = NULL)
[01:28:08.324]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.324]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.324]                 }
[01:28:08.324]                 ...future.workdir <- getwd()
[01:28:08.324]             }
[01:28:08.324]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.324]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.324]         }
[01:28:08.324]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.324]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.324]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.324]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.324]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.324]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.324]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.324]             base::names(...future.oldOptions))
[01:28:08.324]     }
[01:28:08.324]     if (FALSE) {
[01:28:08.324]     }
[01:28:08.324]     else {
[01:28:08.324]         if (TRUE) {
[01:28:08.324]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.324]                 open = "w")
[01:28:08.324]         }
[01:28:08.324]         else {
[01:28:08.324]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.324]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.324]         }
[01:28:08.324]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.324]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.324]             base::sink(type = "output", split = FALSE)
[01:28:08.324]             base::close(...future.stdout)
[01:28:08.324]         }, add = TRUE)
[01:28:08.324]     }
[01:28:08.324]     ...future.frame <- base::sys.nframe()
[01:28:08.324]     ...future.conditions <- base::list()
[01:28:08.324]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.324]     if (FALSE) {
[01:28:08.324]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.324]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.324]     }
[01:28:08.324]     ...future.result <- base::tryCatch({
[01:28:08.324]         base::withCallingHandlers({
[01:28:08.324]             ...future.value <- base::withVisible(base::local({
[01:28:08.324]                 b <- a * ii
[01:28:08.324]                 a <- 0
[01:28:08.324]                 b
[01:28:08.324]             }))
[01:28:08.324]             future::FutureResult(value = ...future.value$value, 
[01:28:08.324]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.324]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.324]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.324]                     ...future.globalenv.names))
[01:28:08.324]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.324]         }, condition = base::local({
[01:28:08.324]             c <- base::c
[01:28:08.324]             inherits <- base::inherits
[01:28:08.324]             invokeRestart <- base::invokeRestart
[01:28:08.324]             length <- base::length
[01:28:08.324]             list <- base::list
[01:28:08.324]             seq.int <- base::seq.int
[01:28:08.324]             signalCondition <- base::signalCondition
[01:28:08.324]             sys.calls <- base::sys.calls
[01:28:08.324]             `[[` <- base::`[[`
[01:28:08.324]             `+` <- base::`+`
[01:28:08.324]             `<<-` <- base::`<<-`
[01:28:08.324]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.324]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.324]                   3L)]
[01:28:08.324]             }
[01:28:08.324]             function(cond) {
[01:28:08.324]                 is_error <- inherits(cond, "error")
[01:28:08.324]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.324]                   NULL)
[01:28:08.324]                 if (is_error) {
[01:28:08.324]                   sessionInformation <- function() {
[01:28:08.324]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.324]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.324]                       search = base::search(), system = base::Sys.info())
[01:28:08.324]                   }
[01:28:08.324]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.324]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.324]                     cond$call), session = sessionInformation(), 
[01:28:08.324]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.324]                   signalCondition(cond)
[01:28:08.324]                 }
[01:28:08.324]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.324]                 "immediateCondition"))) {
[01:28:08.324]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.324]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.324]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.324]                   if (TRUE && !signal) {
[01:28:08.324]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.324]                     {
[01:28:08.324]                       inherits <- base::inherits
[01:28:08.324]                       invokeRestart <- base::invokeRestart
[01:28:08.324]                       is.null <- base::is.null
[01:28:08.324]                       muffled <- FALSE
[01:28:08.324]                       if (inherits(cond, "message")) {
[01:28:08.324]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.324]                         if (muffled) 
[01:28:08.324]                           invokeRestart("muffleMessage")
[01:28:08.324]                       }
[01:28:08.324]                       else if (inherits(cond, "warning")) {
[01:28:08.324]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.324]                         if (muffled) 
[01:28:08.324]                           invokeRestart("muffleWarning")
[01:28:08.324]                       }
[01:28:08.324]                       else if (inherits(cond, "condition")) {
[01:28:08.324]                         if (!is.null(pattern)) {
[01:28:08.324]                           computeRestarts <- base::computeRestarts
[01:28:08.324]                           grepl <- base::grepl
[01:28:08.324]                           restarts <- computeRestarts(cond)
[01:28:08.324]                           for (restart in restarts) {
[01:28:08.324]                             name <- restart$name
[01:28:08.324]                             if (is.null(name)) 
[01:28:08.324]                               next
[01:28:08.324]                             if (!grepl(pattern, name)) 
[01:28:08.324]                               next
[01:28:08.324]                             invokeRestart(restart)
[01:28:08.324]                             muffled <- TRUE
[01:28:08.324]                             break
[01:28:08.324]                           }
[01:28:08.324]                         }
[01:28:08.324]                       }
[01:28:08.324]                       invisible(muffled)
[01:28:08.324]                     }
[01:28:08.324]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.324]                   }
[01:28:08.324]                 }
[01:28:08.324]                 else {
[01:28:08.324]                   if (TRUE) {
[01:28:08.324]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.324]                     {
[01:28:08.324]                       inherits <- base::inherits
[01:28:08.324]                       invokeRestart <- base::invokeRestart
[01:28:08.324]                       is.null <- base::is.null
[01:28:08.324]                       muffled <- FALSE
[01:28:08.324]                       if (inherits(cond, "message")) {
[01:28:08.324]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.324]                         if (muffled) 
[01:28:08.324]                           invokeRestart("muffleMessage")
[01:28:08.324]                       }
[01:28:08.324]                       else if (inherits(cond, "warning")) {
[01:28:08.324]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.324]                         if (muffled) 
[01:28:08.324]                           invokeRestart("muffleWarning")
[01:28:08.324]                       }
[01:28:08.324]                       else if (inherits(cond, "condition")) {
[01:28:08.324]                         if (!is.null(pattern)) {
[01:28:08.324]                           computeRestarts <- base::computeRestarts
[01:28:08.324]                           grepl <- base::grepl
[01:28:08.324]                           restarts <- computeRestarts(cond)
[01:28:08.324]                           for (restart in restarts) {
[01:28:08.324]                             name <- restart$name
[01:28:08.324]                             if (is.null(name)) 
[01:28:08.324]                               next
[01:28:08.324]                             if (!grepl(pattern, name)) 
[01:28:08.324]                               next
[01:28:08.324]                             invokeRestart(restart)
[01:28:08.324]                             muffled <- TRUE
[01:28:08.324]                             break
[01:28:08.324]                           }
[01:28:08.324]                         }
[01:28:08.324]                       }
[01:28:08.324]                       invisible(muffled)
[01:28:08.324]                     }
[01:28:08.324]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.324]                   }
[01:28:08.324]                 }
[01:28:08.324]             }
[01:28:08.324]         }))
[01:28:08.324]     }, error = function(ex) {
[01:28:08.324]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.324]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.324]                 ...future.rng), started = ...future.startTime, 
[01:28:08.324]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.324]             version = "1.8"), class = "FutureResult")
[01:28:08.324]     }, finally = {
[01:28:08.324]         if (!identical(...future.workdir, getwd())) 
[01:28:08.324]             setwd(...future.workdir)
[01:28:08.324]         {
[01:28:08.324]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.324]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.324]             }
[01:28:08.324]             base::options(...future.oldOptions)
[01:28:08.324]             if (.Platform$OS.type == "windows") {
[01:28:08.324]                 old_names <- names(...future.oldEnvVars)
[01:28:08.324]                 envs <- base::Sys.getenv()
[01:28:08.324]                 names <- names(envs)
[01:28:08.324]                 common <- intersect(names, old_names)
[01:28:08.324]                 added <- setdiff(names, old_names)
[01:28:08.324]                 removed <- setdiff(old_names, names)
[01:28:08.324]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.324]                   envs[common]]
[01:28:08.324]                 NAMES <- toupper(changed)
[01:28:08.324]                 args <- list()
[01:28:08.324]                 for (kk in seq_along(NAMES)) {
[01:28:08.324]                   name <- changed[[kk]]
[01:28:08.324]                   NAME <- NAMES[[kk]]
[01:28:08.324]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.324]                     next
[01:28:08.324]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.324]                 }
[01:28:08.324]                 NAMES <- toupper(added)
[01:28:08.324]                 for (kk in seq_along(NAMES)) {
[01:28:08.324]                   name <- added[[kk]]
[01:28:08.324]                   NAME <- NAMES[[kk]]
[01:28:08.324]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.324]                     next
[01:28:08.324]                   args[[name]] <- ""
[01:28:08.324]                 }
[01:28:08.324]                 NAMES <- toupper(removed)
[01:28:08.324]                 for (kk in seq_along(NAMES)) {
[01:28:08.324]                   name <- removed[[kk]]
[01:28:08.324]                   NAME <- NAMES[[kk]]
[01:28:08.324]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.324]                     next
[01:28:08.324]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.324]                 }
[01:28:08.324]                 if (length(args) > 0) 
[01:28:08.324]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.324]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.324]             }
[01:28:08.324]             else {
[01:28:08.324]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.324]             }
[01:28:08.324]             {
[01:28:08.324]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.324]                   0L) {
[01:28:08.324]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.324]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.324]                   base::options(opts)
[01:28:08.324]                 }
[01:28:08.324]                 {
[01:28:08.324]                   {
[01:28:08.324]                     NULL
[01:28:08.324]                     RNGkind("Mersenne-Twister")
[01:28:08.324]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.324]                       inherits = FALSE)
[01:28:08.324]                   }
[01:28:08.324]                   options(future.plan = NULL)
[01:28:08.324]                   if (is.na(NA_character_)) 
[01:28:08.324]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.324]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.324]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.324]                   {
[01:28:08.324]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.324]                     if (!future$lazy) 
[01:28:08.324]                       future <- run(future)
[01:28:08.324]                     invisible(future)
[01:28:08.324]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.324]                 }
[01:28:08.324]             }
[01:28:08.324]         }
[01:28:08.324]     })
[01:28:08.324]     if (TRUE) {
[01:28:08.324]         base::sink(type = "output", split = FALSE)
[01:28:08.324]         if (TRUE) {
[01:28:08.324]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.324]         }
[01:28:08.324]         else {
[01:28:08.324]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.324]         }
[01:28:08.324]         base::close(...future.stdout)
[01:28:08.324]         ...future.stdout <- NULL
[01:28:08.324]     }
[01:28:08.324]     ...future.result$conditions <- ...future.conditions
[01:28:08.324]     ...future.result$finished <- base::Sys.time()
[01:28:08.324]     ...future.result
[01:28:08.324] }
[01:28:08.328] assign_globals() ...
[01:28:08.328] List of 2
[01:28:08.328]  $ a : num 1
[01:28:08.328]  $ ii: int 1
[01:28:08.328]  - attr(*, "where")=List of 2
[01:28:08.328]   ..$ a :<environment: R_EmptyEnv> 
[01:28:08.328]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:08.328]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.328]  - attr(*, "resolved")= logi TRUE
[01:28:08.328]  - attr(*, "total_size")= num 112
[01:28:08.328]  - attr(*, "already-done")= logi TRUE
[01:28:08.332] - copied 'a' to environment
[01:28:08.332] - copied 'ii' to environment
[01:28:08.332] assign_globals() ... done
[01:28:08.332] plan(): Setting new future strategy stack:
[01:28:08.333] List of future strategies:
[01:28:08.333] 1. sequential:
[01:28:08.333]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.333]    - tweaked: FALSE
[01:28:08.333]    - call: NULL
[01:28:08.333] plan(): nbrOfWorkers() = 1
[01:28:08.334] plan(): Setting new future strategy stack:
[01:28:08.334] List of future strategies:
[01:28:08.334] 1. sequential:
[01:28:08.334]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.334]    - tweaked: FALSE
[01:28:08.334]    - call: plan(strategy)
[01:28:08.335] plan(): nbrOfWorkers() = 1
[01:28:08.335] SequentialFuture started (and completed)
[01:28:08.335] - Launch lazy future ... done
[01:28:08.336] run() for 'SequentialFuture' ... done
[01:28:08.336] run() for 'Future' ...
[01:28:08.336] - state: 'created'
[01:28:08.336] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.337] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.337] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.337]   - Field: 'label'
[01:28:08.337]   - Field: 'local'
[01:28:08.337]   - Field: 'owner'
[01:28:08.338]   - Field: 'envir'
[01:28:08.338]   - Field: 'packages'
[01:28:08.338]   - Field: 'gc'
[01:28:08.338]   - Field: 'conditions'
[01:28:08.338]   - Field: 'expr'
[01:28:08.339]   - Field: 'uuid'
[01:28:08.339]   - Field: 'seed'
[01:28:08.339]   - Field: 'version'
[01:28:08.339]   - Field: 'result'
[01:28:08.339]   - Field: 'asynchronous'
[01:28:08.339]   - Field: 'calls'
[01:28:08.340]   - Field: 'globals'
[01:28:08.340]   - Field: 'stdout'
[01:28:08.340]   - Field: 'earlySignal'
[01:28:08.340]   - Field: 'lazy'
[01:28:08.340]   - Field: 'state'
[01:28:08.341] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.341] - Launch lazy future ...
[01:28:08.341] Packages needed by the future expression (n = 0): <none>
[01:28:08.341] Packages needed by future strategies (n = 0): <none>
[01:28:08.342] {
[01:28:08.342]     {
[01:28:08.342]         {
[01:28:08.342]             ...future.startTime <- base::Sys.time()
[01:28:08.342]             {
[01:28:08.342]                 {
[01:28:08.342]                   {
[01:28:08.342]                     base::local({
[01:28:08.342]                       has_future <- base::requireNamespace("future", 
[01:28:08.342]                         quietly = TRUE)
[01:28:08.342]                       if (has_future) {
[01:28:08.342]                         ns <- base::getNamespace("future")
[01:28:08.342]                         version <- ns[[".package"]][["version"]]
[01:28:08.342]                         if (is.null(version)) 
[01:28:08.342]                           version <- utils::packageVersion("future")
[01:28:08.342]                       }
[01:28:08.342]                       else {
[01:28:08.342]                         version <- NULL
[01:28:08.342]                       }
[01:28:08.342]                       if (!has_future || version < "1.8.0") {
[01:28:08.342]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.342]                           "", base::R.version$version.string), 
[01:28:08.342]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.342]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.342]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.342]                             "release", "version")], collapse = " "), 
[01:28:08.342]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.342]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.342]                           info)
[01:28:08.342]                         info <- base::paste(info, collapse = "; ")
[01:28:08.342]                         if (!has_future) {
[01:28:08.342]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.342]                             info)
[01:28:08.342]                         }
[01:28:08.342]                         else {
[01:28:08.342]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.342]                             info, version)
[01:28:08.342]                         }
[01:28:08.342]                         base::stop(msg)
[01:28:08.342]                       }
[01:28:08.342]                     })
[01:28:08.342]                   }
[01:28:08.342]                   options(future.plan = NULL)
[01:28:08.342]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.342]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.342]                 }
[01:28:08.342]                 ...future.workdir <- getwd()
[01:28:08.342]             }
[01:28:08.342]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.342]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.342]         }
[01:28:08.342]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.342]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.342]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.342]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.342]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.342]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.342]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.342]             base::names(...future.oldOptions))
[01:28:08.342]     }
[01:28:08.342]     if (FALSE) {
[01:28:08.342]     }
[01:28:08.342]     else {
[01:28:08.342]         if (TRUE) {
[01:28:08.342]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.342]                 open = "w")
[01:28:08.342]         }
[01:28:08.342]         else {
[01:28:08.342]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.342]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.342]         }
[01:28:08.342]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.342]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.342]             base::sink(type = "output", split = FALSE)
[01:28:08.342]             base::close(...future.stdout)
[01:28:08.342]         }, add = TRUE)
[01:28:08.342]     }
[01:28:08.342]     ...future.frame <- base::sys.nframe()
[01:28:08.342]     ...future.conditions <- base::list()
[01:28:08.342]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.342]     if (FALSE) {
[01:28:08.342]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.342]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.342]     }
[01:28:08.342]     ...future.result <- base::tryCatch({
[01:28:08.342]         base::withCallingHandlers({
[01:28:08.342]             ...future.value <- base::withVisible(base::local({
[01:28:08.342]                 b <- a * ii
[01:28:08.342]                 a <- 0
[01:28:08.342]                 b
[01:28:08.342]             }))
[01:28:08.342]             future::FutureResult(value = ...future.value$value, 
[01:28:08.342]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.342]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.342]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.342]                     ...future.globalenv.names))
[01:28:08.342]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.342]         }, condition = base::local({
[01:28:08.342]             c <- base::c
[01:28:08.342]             inherits <- base::inherits
[01:28:08.342]             invokeRestart <- base::invokeRestart
[01:28:08.342]             length <- base::length
[01:28:08.342]             list <- base::list
[01:28:08.342]             seq.int <- base::seq.int
[01:28:08.342]             signalCondition <- base::signalCondition
[01:28:08.342]             sys.calls <- base::sys.calls
[01:28:08.342]             `[[` <- base::`[[`
[01:28:08.342]             `+` <- base::`+`
[01:28:08.342]             `<<-` <- base::`<<-`
[01:28:08.342]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.342]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.342]                   3L)]
[01:28:08.342]             }
[01:28:08.342]             function(cond) {
[01:28:08.342]                 is_error <- inherits(cond, "error")
[01:28:08.342]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.342]                   NULL)
[01:28:08.342]                 if (is_error) {
[01:28:08.342]                   sessionInformation <- function() {
[01:28:08.342]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.342]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.342]                       search = base::search(), system = base::Sys.info())
[01:28:08.342]                   }
[01:28:08.342]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.342]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.342]                     cond$call), session = sessionInformation(), 
[01:28:08.342]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.342]                   signalCondition(cond)
[01:28:08.342]                 }
[01:28:08.342]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.342]                 "immediateCondition"))) {
[01:28:08.342]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.342]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.342]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.342]                   if (TRUE && !signal) {
[01:28:08.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.342]                     {
[01:28:08.342]                       inherits <- base::inherits
[01:28:08.342]                       invokeRestart <- base::invokeRestart
[01:28:08.342]                       is.null <- base::is.null
[01:28:08.342]                       muffled <- FALSE
[01:28:08.342]                       if (inherits(cond, "message")) {
[01:28:08.342]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.342]                         if (muffled) 
[01:28:08.342]                           invokeRestart("muffleMessage")
[01:28:08.342]                       }
[01:28:08.342]                       else if (inherits(cond, "warning")) {
[01:28:08.342]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.342]                         if (muffled) 
[01:28:08.342]                           invokeRestart("muffleWarning")
[01:28:08.342]                       }
[01:28:08.342]                       else if (inherits(cond, "condition")) {
[01:28:08.342]                         if (!is.null(pattern)) {
[01:28:08.342]                           computeRestarts <- base::computeRestarts
[01:28:08.342]                           grepl <- base::grepl
[01:28:08.342]                           restarts <- computeRestarts(cond)
[01:28:08.342]                           for (restart in restarts) {
[01:28:08.342]                             name <- restart$name
[01:28:08.342]                             if (is.null(name)) 
[01:28:08.342]                               next
[01:28:08.342]                             if (!grepl(pattern, name)) 
[01:28:08.342]                               next
[01:28:08.342]                             invokeRestart(restart)
[01:28:08.342]                             muffled <- TRUE
[01:28:08.342]                             break
[01:28:08.342]                           }
[01:28:08.342]                         }
[01:28:08.342]                       }
[01:28:08.342]                       invisible(muffled)
[01:28:08.342]                     }
[01:28:08.342]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.342]                   }
[01:28:08.342]                 }
[01:28:08.342]                 else {
[01:28:08.342]                   if (TRUE) {
[01:28:08.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.342]                     {
[01:28:08.342]                       inherits <- base::inherits
[01:28:08.342]                       invokeRestart <- base::invokeRestart
[01:28:08.342]                       is.null <- base::is.null
[01:28:08.342]                       muffled <- FALSE
[01:28:08.342]                       if (inherits(cond, "message")) {
[01:28:08.342]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.342]                         if (muffled) 
[01:28:08.342]                           invokeRestart("muffleMessage")
[01:28:08.342]                       }
[01:28:08.342]                       else if (inherits(cond, "warning")) {
[01:28:08.342]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.342]                         if (muffled) 
[01:28:08.342]                           invokeRestart("muffleWarning")
[01:28:08.342]                       }
[01:28:08.342]                       else if (inherits(cond, "condition")) {
[01:28:08.342]                         if (!is.null(pattern)) {
[01:28:08.342]                           computeRestarts <- base::computeRestarts
[01:28:08.342]                           grepl <- base::grepl
[01:28:08.342]                           restarts <- computeRestarts(cond)
[01:28:08.342]                           for (restart in restarts) {
[01:28:08.342]                             name <- restart$name
[01:28:08.342]                             if (is.null(name)) 
[01:28:08.342]                               next
[01:28:08.342]                             if (!grepl(pattern, name)) 
[01:28:08.342]                               next
[01:28:08.342]                             invokeRestart(restart)
[01:28:08.342]                             muffled <- TRUE
[01:28:08.342]                             break
[01:28:08.342]                           }
[01:28:08.342]                         }
[01:28:08.342]                       }
[01:28:08.342]                       invisible(muffled)
[01:28:08.342]                     }
[01:28:08.342]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.342]                   }
[01:28:08.342]                 }
[01:28:08.342]             }
[01:28:08.342]         }))
[01:28:08.342]     }, error = function(ex) {
[01:28:08.342]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.342]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.342]                 ...future.rng), started = ...future.startTime, 
[01:28:08.342]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.342]             version = "1.8"), class = "FutureResult")
[01:28:08.342]     }, finally = {
[01:28:08.342]         if (!identical(...future.workdir, getwd())) 
[01:28:08.342]             setwd(...future.workdir)
[01:28:08.342]         {
[01:28:08.342]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.342]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.342]             }
[01:28:08.342]             base::options(...future.oldOptions)
[01:28:08.342]             if (.Platform$OS.type == "windows") {
[01:28:08.342]                 old_names <- names(...future.oldEnvVars)
[01:28:08.342]                 envs <- base::Sys.getenv()
[01:28:08.342]                 names <- names(envs)
[01:28:08.342]                 common <- intersect(names, old_names)
[01:28:08.342]                 added <- setdiff(names, old_names)
[01:28:08.342]                 removed <- setdiff(old_names, names)
[01:28:08.342]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.342]                   envs[common]]
[01:28:08.342]                 NAMES <- toupper(changed)
[01:28:08.342]                 args <- list()
[01:28:08.342]                 for (kk in seq_along(NAMES)) {
[01:28:08.342]                   name <- changed[[kk]]
[01:28:08.342]                   NAME <- NAMES[[kk]]
[01:28:08.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.342]                     next
[01:28:08.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.342]                 }
[01:28:08.342]                 NAMES <- toupper(added)
[01:28:08.342]                 for (kk in seq_along(NAMES)) {
[01:28:08.342]                   name <- added[[kk]]
[01:28:08.342]                   NAME <- NAMES[[kk]]
[01:28:08.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.342]                     next
[01:28:08.342]                   args[[name]] <- ""
[01:28:08.342]                 }
[01:28:08.342]                 NAMES <- toupper(removed)
[01:28:08.342]                 for (kk in seq_along(NAMES)) {
[01:28:08.342]                   name <- removed[[kk]]
[01:28:08.342]                   NAME <- NAMES[[kk]]
[01:28:08.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.342]                     next
[01:28:08.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.342]                 }
[01:28:08.342]                 if (length(args) > 0) 
[01:28:08.342]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.342]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.342]             }
[01:28:08.342]             else {
[01:28:08.342]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.342]             }
[01:28:08.342]             {
[01:28:08.342]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.342]                   0L) {
[01:28:08.342]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.342]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.342]                   base::options(opts)
[01:28:08.342]                 }
[01:28:08.342]                 {
[01:28:08.342]                   {
[01:28:08.342]                     NULL
[01:28:08.342]                     RNGkind("Mersenne-Twister")
[01:28:08.342]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.342]                       inherits = FALSE)
[01:28:08.342]                   }
[01:28:08.342]                   options(future.plan = NULL)
[01:28:08.342]                   if (is.na(NA_character_)) 
[01:28:08.342]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.342]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.342]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.342]                   {
[01:28:08.342]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.342]                     if (!future$lazy) 
[01:28:08.342]                       future <- run(future)
[01:28:08.342]                     invisible(future)
[01:28:08.342]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.342]                 }
[01:28:08.342]             }
[01:28:08.342]         }
[01:28:08.342]     })
[01:28:08.342]     if (TRUE) {
[01:28:08.342]         base::sink(type = "output", split = FALSE)
[01:28:08.342]         if (TRUE) {
[01:28:08.342]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.342]         }
[01:28:08.342]         else {
[01:28:08.342]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.342]         }
[01:28:08.342]         base::close(...future.stdout)
[01:28:08.342]         ...future.stdout <- NULL
[01:28:08.342]     }
[01:28:08.342]     ...future.result$conditions <- ...future.conditions
[01:28:08.342]     ...future.result$finished <- base::Sys.time()
[01:28:08.342]     ...future.result
[01:28:08.342] }
[01:28:08.345] assign_globals() ...
[01:28:08.346] List of 2
[01:28:08.346]  $ a : num 1
[01:28:08.346]  $ ii: int 2
[01:28:08.346]  - attr(*, "where")=List of 2
[01:28:08.346]   ..$ a :<environment: R_EmptyEnv> 
[01:28:08.346]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:08.346]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.346]  - attr(*, "resolved")= logi TRUE
[01:28:08.346]  - attr(*, "total_size")= num 112
[01:28:08.346]  - attr(*, "already-done")= logi TRUE
[01:28:08.349] - copied 'a' to environment
[01:28:08.350] - copied 'ii' to environment
[01:28:08.350] assign_globals() ... done
[01:28:08.350] plan(): Setting new future strategy stack:
[01:28:08.350] List of future strategies:
[01:28:08.350] 1. sequential:
[01:28:08.350]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.350]    - tweaked: FALSE
[01:28:08.350]    - call: NULL
[01:28:08.351] plan(): nbrOfWorkers() = 1
[01:28:08.352] plan(): Setting new future strategy stack:
[01:28:08.352] List of future strategies:
[01:28:08.352] 1. sequential:
[01:28:08.352]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.352]    - tweaked: FALSE
[01:28:08.352]    - call: plan(strategy)
[01:28:08.353] plan(): nbrOfWorkers() = 1
[01:28:08.353] SequentialFuture started (and completed)
[01:28:08.353] - Launch lazy future ... done
[01:28:08.353] run() for 'SequentialFuture' ... done
[01:28:08.354] run() for 'Future' ...
[01:28:08.354] - state: 'created'
[01:28:08.354] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.355] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.355] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.355]   - Field: 'label'
[01:28:08.355]   - Field: 'local'
[01:28:08.355]   - Field: 'owner'
[01:28:08.356]   - Field: 'envir'
[01:28:08.356]   - Field: 'packages'
[01:28:08.356]   - Field: 'gc'
[01:28:08.356]   - Field: 'conditions'
[01:28:08.356]   - Field: 'expr'
[01:28:08.357]   - Field: 'uuid'
[01:28:08.357]   - Field: 'seed'
[01:28:08.357]   - Field: 'version'
[01:28:08.357]   - Field: 'result'
[01:28:08.358]   - Field: 'asynchronous'
[01:28:08.358]   - Field: 'calls'
[01:28:08.358]   - Field: 'globals'
[01:28:08.359]   - Field: 'stdout'
[01:28:08.359]   - Field: 'earlySignal'
[01:28:08.359]   - Field: 'lazy'
[01:28:08.359]   - Field: 'state'
[01:28:08.359] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.359] - Launch lazy future ...
[01:28:08.360] Packages needed by the future expression (n = 0): <none>
[01:28:08.360] Packages needed by future strategies (n = 0): <none>
[01:28:08.360] {
[01:28:08.360]     {
[01:28:08.360]         {
[01:28:08.360]             ...future.startTime <- base::Sys.time()
[01:28:08.360]             {
[01:28:08.360]                 {
[01:28:08.360]                   {
[01:28:08.360]                     base::local({
[01:28:08.360]                       has_future <- base::requireNamespace("future", 
[01:28:08.360]                         quietly = TRUE)
[01:28:08.360]                       if (has_future) {
[01:28:08.360]                         ns <- base::getNamespace("future")
[01:28:08.360]                         version <- ns[[".package"]][["version"]]
[01:28:08.360]                         if (is.null(version)) 
[01:28:08.360]                           version <- utils::packageVersion("future")
[01:28:08.360]                       }
[01:28:08.360]                       else {
[01:28:08.360]                         version <- NULL
[01:28:08.360]                       }
[01:28:08.360]                       if (!has_future || version < "1.8.0") {
[01:28:08.360]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.360]                           "", base::R.version$version.string), 
[01:28:08.360]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.360]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.360]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.360]                             "release", "version")], collapse = " "), 
[01:28:08.360]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.360]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.360]                           info)
[01:28:08.360]                         info <- base::paste(info, collapse = "; ")
[01:28:08.360]                         if (!has_future) {
[01:28:08.360]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.360]                             info)
[01:28:08.360]                         }
[01:28:08.360]                         else {
[01:28:08.360]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.360]                             info, version)
[01:28:08.360]                         }
[01:28:08.360]                         base::stop(msg)
[01:28:08.360]                       }
[01:28:08.360]                     })
[01:28:08.360]                   }
[01:28:08.360]                   options(future.plan = NULL)
[01:28:08.360]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.360]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.360]                 }
[01:28:08.360]                 ...future.workdir <- getwd()
[01:28:08.360]             }
[01:28:08.360]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.360]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.360]         }
[01:28:08.360]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.360]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.360]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.360]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.360]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.360]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.360]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.360]             base::names(...future.oldOptions))
[01:28:08.360]     }
[01:28:08.360]     if (FALSE) {
[01:28:08.360]     }
[01:28:08.360]     else {
[01:28:08.360]         if (TRUE) {
[01:28:08.360]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.360]                 open = "w")
[01:28:08.360]         }
[01:28:08.360]         else {
[01:28:08.360]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.360]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.360]         }
[01:28:08.360]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.360]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.360]             base::sink(type = "output", split = FALSE)
[01:28:08.360]             base::close(...future.stdout)
[01:28:08.360]         }, add = TRUE)
[01:28:08.360]     }
[01:28:08.360]     ...future.frame <- base::sys.nframe()
[01:28:08.360]     ...future.conditions <- base::list()
[01:28:08.360]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.360]     if (FALSE) {
[01:28:08.360]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.360]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.360]     }
[01:28:08.360]     ...future.result <- base::tryCatch({
[01:28:08.360]         base::withCallingHandlers({
[01:28:08.360]             ...future.value <- base::withVisible(base::local({
[01:28:08.360]                 b <- a * ii
[01:28:08.360]                 a <- 0
[01:28:08.360]                 b
[01:28:08.360]             }))
[01:28:08.360]             future::FutureResult(value = ...future.value$value, 
[01:28:08.360]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.360]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.360]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.360]                     ...future.globalenv.names))
[01:28:08.360]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.360]         }, condition = base::local({
[01:28:08.360]             c <- base::c
[01:28:08.360]             inherits <- base::inherits
[01:28:08.360]             invokeRestart <- base::invokeRestart
[01:28:08.360]             length <- base::length
[01:28:08.360]             list <- base::list
[01:28:08.360]             seq.int <- base::seq.int
[01:28:08.360]             signalCondition <- base::signalCondition
[01:28:08.360]             sys.calls <- base::sys.calls
[01:28:08.360]             `[[` <- base::`[[`
[01:28:08.360]             `+` <- base::`+`
[01:28:08.360]             `<<-` <- base::`<<-`
[01:28:08.360]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.360]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.360]                   3L)]
[01:28:08.360]             }
[01:28:08.360]             function(cond) {
[01:28:08.360]                 is_error <- inherits(cond, "error")
[01:28:08.360]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.360]                   NULL)
[01:28:08.360]                 if (is_error) {
[01:28:08.360]                   sessionInformation <- function() {
[01:28:08.360]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.360]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.360]                       search = base::search(), system = base::Sys.info())
[01:28:08.360]                   }
[01:28:08.360]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.360]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.360]                     cond$call), session = sessionInformation(), 
[01:28:08.360]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.360]                   signalCondition(cond)
[01:28:08.360]                 }
[01:28:08.360]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.360]                 "immediateCondition"))) {
[01:28:08.360]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.360]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.360]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.360]                   if (TRUE && !signal) {
[01:28:08.360]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.360]                     {
[01:28:08.360]                       inherits <- base::inherits
[01:28:08.360]                       invokeRestart <- base::invokeRestart
[01:28:08.360]                       is.null <- base::is.null
[01:28:08.360]                       muffled <- FALSE
[01:28:08.360]                       if (inherits(cond, "message")) {
[01:28:08.360]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.360]                         if (muffled) 
[01:28:08.360]                           invokeRestart("muffleMessage")
[01:28:08.360]                       }
[01:28:08.360]                       else if (inherits(cond, "warning")) {
[01:28:08.360]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.360]                         if (muffled) 
[01:28:08.360]                           invokeRestart("muffleWarning")
[01:28:08.360]                       }
[01:28:08.360]                       else if (inherits(cond, "condition")) {
[01:28:08.360]                         if (!is.null(pattern)) {
[01:28:08.360]                           computeRestarts <- base::computeRestarts
[01:28:08.360]                           grepl <- base::grepl
[01:28:08.360]                           restarts <- computeRestarts(cond)
[01:28:08.360]                           for (restart in restarts) {
[01:28:08.360]                             name <- restart$name
[01:28:08.360]                             if (is.null(name)) 
[01:28:08.360]                               next
[01:28:08.360]                             if (!grepl(pattern, name)) 
[01:28:08.360]                               next
[01:28:08.360]                             invokeRestart(restart)
[01:28:08.360]                             muffled <- TRUE
[01:28:08.360]                             break
[01:28:08.360]                           }
[01:28:08.360]                         }
[01:28:08.360]                       }
[01:28:08.360]                       invisible(muffled)
[01:28:08.360]                     }
[01:28:08.360]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.360]                   }
[01:28:08.360]                 }
[01:28:08.360]                 else {
[01:28:08.360]                   if (TRUE) {
[01:28:08.360]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.360]                     {
[01:28:08.360]                       inherits <- base::inherits
[01:28:08.360]                       invokeRestart <- base::invokeRestart
[01:28:08.360]                       is.null <- base::is.null
[01:28:08.360]                       muffled <- FALSE
[01:28:08.360]                       if (inherits(cond, "message")) {
[01:28:08.360]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.360]                         if (muffled) 
[01:28:08.360]                           invokeRestart("muffleMessage")
[01:28:08.360]                       }
[01:28:08.360]                       else if (inherits(cond, "warning")) {
[01:28:08.360]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.360]                         if (muffled) 
[01:28:08.360]                           invokeRestart("muffleWarning")
[01:28:08.360]                       }
[01:28:08.360]                       else if (inherits(cond, "condition")) {
[01:28:08.360]                         if (!is.null(pattern)) {
[01:28:08.360]                           computeRestarts <- base::computeRestarts
[01:28:08.360]                           grepl <- base::grepl
[01:28:08.360]                           restarts <- computeRestarts(cond)
[01:28:08.360]                           for (restart in restarts) {
[01:28:08.360]                             name <- restart$name
[01:28:08.360]                             if (is.null(name)) 
[01:28:08.360]                               next
[01:28:08.360]                             if (!grepl(pattern, name)) 
[01:28:08.360]                               next
[01:28:08.360]                             invokeRestart(restart)
[01:28:08.360]                             muffled <- TRUE
[01:28:08.360]                             break
[01:28:08.360]                           }
[01:28:08.360]                         }
[01:28:08.360]                       }
[01:28:08.360]                       invisible(muffled)
[01:28:08.360]                     }
[01:28:08.360]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.360]                   }
[01:28:08.360]                 }
[01:28:08.360]             }
[01:28:08.360]         }))
[01:28:08.360]     }, error = function(ex) {
[01:28:08.360]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.360]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.360]                 ...future.rng), started = ...future.startTime, 
[01:28:08.360]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.360]             version = "1.8"), class = "FutureResult")
[01:28:08.360]     }, finally = {
[01:28:08.360]         if (!identical(...future.workdir, getwd())) 
[01:28:08.360]             setwd(...future.workdir)
[01:28:08.360]         {
[01:28:08.360]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.360]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.360]             }
[01:28:08.360]             base::options(...future.oldOptions)
[01:28:08.360]             if (.Platform$OS.type == "windows") {
[01:28:08.360]                 old_names <- names(...future.oldEnvVars)
[01:28:08.360]                 envs <- base::Sys.getenv()
[01:28:08.360]                 names <- names(envs)
[01:28:08.360]                 common <- intersect(names, old_names)
[01:28:08.360]                 added <- setdiff(names, old_names)
[01:28:08.360]                 removed <- setdiff(old_names, names)
[01:28:08.360]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.360]                   envs[common]]
[01:28:08.360]                 NAMES <- toupper(changed)
[01:28:08.360]                 args <- list()
[01:28:08.360]                 for (kk in seq_along(NAMES)) {
[01:28:08.360]                   name <- changed[[kk]]
[01:28:08.360]                   NAME <- NAMES[[kk]]
[01:28:08.360]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.360]                     next
[01:28:08.360]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.360]                 }
[01:28:08.360]                 NAMES <- toupper(added)
[01:28:08.360]                 for (kk in seq_along(NAMES)) {
[01:28:08.360]                   name <- added[[kk]]
[01:28:08.360]                   NAME <- NAMES[[kk]]
[01:28:08.360]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.360]                     next
[01:28:08.360]                   args[[name]] <- ""
[01:28:08.360]                 }
[01:28:08.360]                 NAMES <- toupper(removed)
[01:28:08.360]                 for (kk in seq_along(NAMES)) {
[01:28:08.360]                   name <- removed[[kk]]
[01:28:08.360]                   NAME <- NAMES[[kk]]
[01:28:08.360]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.360]                     next
[01:28:08.360]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.360]                 }
[01:28:08.360]                 if (length(args) > 0) 
[01:28:08.360]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.360]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.360]             }
[01:28:08.360]             else {
[01:28:08.360]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.360]             }
[01:28:08.360]             {
[01:28:08.360]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.360]                   0L) {
[01:28:08.360]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.360]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.360]                   base::options(opts)
[01:28:08.360]                 }
[01:28:08.360]                 {
[01:28:08.360]                   {
[01:28:08.360]                     NULL
[01:28:08.360]                     RNGkind("Mersenne-Twister")
[01:28:08.360]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.360]                       inherits = FALSE)
[01:28:08.360]                   }
[01:28:08.360]                   options(future.plan = NULL)
[01:28:08.360]                   if (is.na(NA_character_)) 
[01:28:08.360]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.360]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.360]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.360]                   {
[01:28:08.360]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.360]                     if (!future$lazy) 
[01:28:08.360]                       future <- run(future)
[01:28:08.360]                     invisible(future)
[01:28:08.360]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.360]                 }
[01:28:08.360]             }
[01:28:08.360]         }
[01:28:08.360]     })
[01:28:08.360]     if (TRUE) {
[01:28:08.360]         base::sink(type = "output", split = FALSE)
[01:28:08.360]         if (TRUE) {
[01:28:08.360]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.360]         }
[01:28:08.360]         else {
[01:28:08.360]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.360]         }
[01:28:08.360]         base::close(...future.stdout)
[01:28:08.360]         ...future.stdout <- NULL
[01:28:08.360]     }
[01:28:08.360]     ...future.result$conditions <- ...future.conditions
[01:28:08.360]     ...future.result$finished <- base::Sys.time()
[01:28:08.360]     ...future.result
[01:28:08.360] }
[01:28:08.364] assign_globals() ...
[01:28:08.364] List of 2
[01:28:08.364]  $ a : num 1
[01:28:08.364]  $ ii: int 3
[01:28:08.364]  - attr(*, "where")=List of 2
[01:28:08.364]   ..$ a :<environment: R_EmptyEnv> 
[01:28:08.364]   ..$ ii:<environment: R_EmptyEnv> 
[01:28:08.364]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.364]  - attr(*, "resolved")= logi TRUE
[01:28:08.364]  - attr(*, "total_size")= num 112
[01:28:08.364]  - attr(*, "already-done")= logi TRUE
[01:28:08.368] - copied 'a' to environment
[01:28:08.368] - copied 'ii' to environment
[01:28:08.368] assign_globals() ... done
[01:28:08.368] plan(): Setting new future strategy stack:
[01:28:08.369] List of future strategies:
[01:28:08.369] 1. sequential:
[01:28:08.369]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.369]    - tweaked: FALSE
[01:28:08.369]    - call: NULL
[01:28:08.369] plan(): nbrOfWorkers() = 1
[01:28:08.370] plan(): Setting new future strategy stack:
[01:28:08.371] List of future strategies:
[01:28:08.371] 1. sequential:
[01:28:08.371]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.371]    - tweaked: FALSE
[01:28:08.371]    - call: plan(strategy)
[01:28:08.371] plan(): nbrOfWorkers() = 1
[01:28:08.371] SequentialFuture started (and completed)
[01:28:08.372] - Launch lazy future ... done
[01:28:08.372] run() for 'SequentialFuture' ... done
[1] 1 2 3
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.372] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.373] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.373] 
[01:28:08.373] Searching for globals ... DONE
[01:28:08.374] - globals: [0] <none>
[01:28:08.374] getGlobalsAndPackages() ... DONE
[01:28:08.374] run() for 'Future' ...
[01:28:08.374] - state: 'created'
[01:28:08.374] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.375] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.375] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.375]   - Field: 'label'
[01:28:08.375]   - Field: 'local'
[01:28:08.375]   - Field: 'owner'
[01:28:08.376]   - Field: 'envir'
[01:28:08.376]   - Field: 'packages'
[01:28:08.376]   - Field: 'gc'
[01:28:08.376]   - Field: 'conditions'
[01:28:08.376]   - Field: 'expr'
[01:28:08.377]   - Field: 'uuid'
[01:28:08.377]   - Field: 'seed'
[01:28:08.377]   - Field: 'version'
[01:28:08.377]   - Field: 'result'
[01:28:08.377]   - Field: 'asynchronous'
[01:28:08.377]   - Field: 'calls'
[01:28:08.378]   - Field: 'globals'
[01:28:08.378]   - Field: 'stdout'
[01:28:08.378]   - Field: 'earlySignal'
[01:28:08.378]   - Field: 'lazy'
[01:28:08.378]   - Field: 'state'
[01:28:08.378] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.379] - Launch lazy future ...
[01:28:08.379] Packages needed by the future expression (n = 0): <none>
[01:28:08.379] Packages needed by future strategies (n = 0): <none>
[01:28:08.380] {
[01:28:08.380]     {
[01:28:08.380]         {
[01:28:08.380]             ...future.startTime <- base::Sys.time()
[01:28:08.380]             {
[01:28:08.380]                 {
[01:28:08.380]                   {
[01:28:08.380]                     base::local({
[01:28:08.380]                       has_future <- base::requireNamespace("future", 
[01:28:08.380]                         quietly = TRUE)
[01:28:08.380]                       if (has_future) {
[01:28:08.380]                         ns <- base::getNamespace("future")
[01:28:08.380]                         version <- ns[[".package"]][["version"]]
[01:28:08.380]                         if (is.null(version)) 
[01:28:08.380]                           version <- utils::packageVersion("future")
[01:28:08.380]                       }
[01:28:08.380]                       else {
[01:28:08.380]                         version <- NULL
[01:28:08.380]                       }
[01:28:08.380]                       if (!has_future || version < "1.8.0") {
[01:28:08.380]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.380]                           "", base::R.version$version.string), 
[01:28:08.380]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.380]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.380]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.380]                             "release", "version")], collapse = " "), 
[01:28:08.380]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.380]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.380]                           info)
[01:28:08.380]                         info <- base::paste(info, collapse = "; ")
[01:28:08.380]                         if (!has_future) {
[01:28:08.380]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.380]                             info)
[01:28:08.380]                         }
[01:28:08.380]                         else {
[01:28:08.380]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.380]                             info, version)
[01:28:08.380]                         }
[01:28:08.380]                         base::stop(msg)
[01:28:08.380]                       }
[01:28:08.380]                     })
[01:28:08.380]                   }
[01:28:08.380]                   options(future.plan = NULL)
[01:28:08.380]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.380]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.380]                 }
[01:28:08.380]                 ...future.workdir <- getwd()
[01:28:08.380]             }
[01:28:08.380]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.380]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.380]         }
[01:28:08.380]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.380]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.380]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.380]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.380]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.380]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.380]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.380]             base::names(...future.oldOptions))
[01:28:08.380]     }
[01:28:08.380]     if (FALSE) {
[01:28:08.380]     }
[01:28:08.380]     else {
[01:28:08.380]         if (TRUE) {
[01:28:08.380]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.380]                 open = "w")
[01:28:08.380]         }
[01:28:08.380]         else {
[01:28:08.380]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.380]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.380]         }
[01:28:08.380]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.380]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.380]             base::sink(type = "output", split = FALSE)
[01:28:08.380]             base::close(...future.stdout)
[01:28:08.380]         }, add = TRUE)
[01:28:08.380]     }
[01:28:08.380]     ...future.frame <- base::sys.nframe()
[01:28:08.380]     ...future.conditions <- base::list()
[01:28:08.380]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.380]     if (FALSE) {
[01:28:08.380]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.380]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.380]     }
[01:28:08.380]     ...future.result <- base::tryCatch({
[01:28:08.380]         base::withCallingHandlers({
[01:28:08.380]             ...future.value <- base::withVisible(base::local(1))
[01:28:08.380]             future::FutureResult(value = ...future.value$value, 
[01:28:08.380]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.380]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.380]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.380]                     ...future.globalenv.names))
[01:28:08.380]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.380]         }, condition = base::local({
[01:28:08.380]             c <- base::c
[01:28:08.380]             inherits <- base::inherits
[01:28:08.380]             invokeRestart <- base::invokeRestart
[01:28:08.380]             length <- base::length
[01:28:08.380]             list <- base::list
[01:28:08.380]             seq.int <- base::seq.int
[01:28:08.380]             signalCondition <- base::signalCondition
[01:28:08.380]             sys.calls <- base::sys.calls
[01:28:08.380]             `[[` <- base::`[[`
[01:28:08.380]             `+` <- base::`+`
[01:28:08.380]             `<<-` <- base::`<<-`
[01:28:08.380]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.380]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.380]                   3L)]
[01:28:08.380]             }
[01:28:08.380]             function(cond) {
[01:28:08.380]                 is_error <- inherits(cond, "error")
[01:28:08.380]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.380]                   NULL)
[01:28:08.380]                 if (is_error) {
[01:28:08.380]                   sessionInformation <- function() {
[01:28:08.380]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.380]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.380]                       search = base::search(), system = base::Sys.info())
[01:28:08.380]                   }
[01:28:08.380]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.380]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.380]                     cond$call), session = sessionInformation(), 
[01:28:08.380]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.380]                   signalCondition(cond)
[01:28:08.380]                 }
[01:28:08.380]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.380]                 "immediateCondition"))) {
[01:28:08.380]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.380]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.380]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.380]                   if (TRUE && !signal) {
[01:28:08.380]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.380]                     {
[01:28:08.380]                       inherits <- base::inherits
[01:28:08.380]                       invokeRestart <- base::invokeRestart
[01:28:08.380]                       is.null <- base::is.null
[01:28:08.380]                       muffled <- FALSE
[01:28:08.380]                       if (inherits(cond, "message")) {
[01:28:08.380]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.380]                         if (muffled) 
[01:28:08.380]                           invokeRestart("muffleMessage")
[01:28:08.380]                       }
[01:28:08.380]                       else if (inherits(cond, "warning")) {
[01:28:08.380]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.380]                         if (muffled) 
[01:28:08.380]                           invokeRestart("muffleWarning")
[01:28:08.380]                       }
[01:28:08.380]                       else if (inherits(cond, "condition")) {
[01:28:08.380]                         if (!is.null(pattern)) {
[01:28:08.380]                           computeRestarts <- base::computeRestarts
[01:28:08.380]                           grepl <- base::grepl
[01:28:08.380]                           restarts <- computeRestarts(cond)
[01:28:08.380]                           for (restart in restarts) {
[01:28:08.380]                             name <- restart$name
[01:28:08.380]                             if (is.null(name)) 
[01:28:08.380]                               next
[01:28:08.380]                             if (!grepl(pattern, name)) 
[01:28:08.380]                               next
[01:28:08.380]                             invokeRestart(restart)
[01:28:08.380]                             muffled <- TRUE
[01:28:08.380]                             break
[01:28:08.380]                           }
[01:28:08.380]                         }
[01:28:08.380]                       }
[01:28:08.380]                       invisible(muffled)
[01:28:08.380]                     }
[01:28:08.380]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.380]                   }
[01:28:08.380]                 }
[01:28:08.380]                 else {
[01:28:08.380]                   if (TRUE) {
[01:28:08.380]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.380]                     {
[01:28:08.380]                       inherits <- base::inherits
[01:28:08.380]                       invokeRestart <- base::invokeRestart
[01:28:08.380]                       is.null <- base::is.null
[01:28:08.380]                       muffled <- FALSE
[01:28:08.380]                       if (inherits(cond, "message")) {
[01:28:08.380]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.380]                         if (muffled) 
[01:28:08.380]                           invokeRestart("muffleMessage")
[01:28:08.380]                       }
[01:28:08.380]                       else if (inherits(cond, "warning")) {
[01:28:08.380]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.380]                         if (muffled) 
[01:28:08.380]                           invokeRestart("muffleWarning")
[01:28:08.380]                       }
[01:28:08.380]                       else if (inherits(cond, "condition")) {
[01:28:08.380]                         if (!is.null(pattern)) {
[01:28:08.380]                           computeRestarts <- base::computeRestarts
[01:28:08.380]                           grepl <- base::grepl
[01:28:08.380]                           restarts <- computeRestarts(cond)
[01:28:08.380]                           for (restart in restarts) {
[01:28:08.380]                             name <- restart$name
[01:28:08.380]                             if (is.null(name)) 
[01:28:08.380]                               next
[01:28:08.380]                             if (!grepl(pattern, name)) 
[01:28:08.380]                               next
[01:28:08.380]                             invokeRestart(restart)
[01:28:08.380]                             muffled <- TRUE
[01:28:08.380]                             break
[01:28:08.380]                           }
[01:28:08.380]                         }
[01:28:08.380]                       }
[01:28:08.380]                       invisible(muffled)
[01:28:08.380]                     }
[01:28:08.380]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.380]                   }
[01:28:08.380]                 }
[01:28:08.380]             }
[01:28:08.380]         }))
[01:28:08.380]     }, error = function(ex) {
[01:28:08.380]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.380]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.380]                 ...future.rng), started = ...future.startTime, 
[01:28:08.380]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.380]             version = "1.8"), class = "FutureResult")
[01:28:08.380]     }, finally = {
[01:28:08.380]         if (!identical(...future.workdir, getwd())) 
[01:28:08.380]             setwd(...future.workdir)
[01:28:08.380]         {
[01:28:08.380]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.380]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.380]             }
[01:28:08.380]             base::options(...future.oldOptions)
[01:28:08.380]             if (.Platform$OS.type == "windows") {
[01:28:08.380]                 old_names <- names(...future.oldEnvVars)
[01:28:08.380]                 envs <- base::Sys.getenv()
[01:28:08.380]                 names <- names(envs)
[01:28:08.380]                 common <- intersect(names, old_names)
[01:28:08.380]                 added <- setdiff(names, old_names)
[01:28:08.380]                 removed <- setdiff(old_names, names)
[01:28:08.380]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.380]                   envs[common]]
[01:28:08.380]                 NAMES <- toupper(changed)
[01:28:08.380]                 args <- list()
[01:28:08.380]                 for (kk in seq_along(NAMES)) {
[01:28:08.380]                   name <- changed[[kk]]
[01:28:08.380]                   NAME <- NAMES[[kk]]
[01:28:08.380]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.380]                     next
[01:28:08.380]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.380]                 }
[01:28:08.380]                 NAMES <- toupper(added)
[01:28:08.380]                 for (kk in seq_along(NAMES)) {
[01:28:08.380]                   name <- added[[kk]]
[01:28:08.380]                   NAME <- NAMES[[kk]]
[01:28:08.380]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.380]                     next
[01:28:08.380]                   args[[name]] <- ""
[01:28:08.380]                 }
[01:28:08.380]                 NAMES <- toupper(removed)
[01:28:08.380]                 for (kk in seq_along(NAMES)) {
[01:28:08.380]                   name <- removed[[kk]]
[01:28:08.380]                   NAME <- NAMES[[kk]]
[01:28:08.380]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.380]                     next
[01:28:08.380]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.380]                 }
[01:28:08.380]                 if (length(args) > 0) 
[01:28:08.380]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.380]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.380]             }
[01:28:08.380]             else {
[01:28:08.380]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.380]             }
[01:28:08.380]             {
[01:28:08.380]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.380]                   0L) {
[01:28:08.380]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.380]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.380]                   base::options(opts)
[01:28:08.380]                 }
[01:28:08.380]                 {
[01:28:08.380]                   {
[01:28:08.380]                     NULL
[01:28:08.380]                     RNGkind("Mersenne-Twister")
[01:28:08.380]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.380]                       inherits = FALSE)
[01:28:08.380]                   }
[01:28:08.380]                   options(future.plan = NULL)
[01:28:08.380]                   if (is.na(NA_character_)) 
[01:28:08.380]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.380]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.380]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.380]                   {
[01:28:08.380]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.380]                     if (!future$lazy) 
[01:28:08.380]                       future <- run(future)
[01:28:08.380]                     invisible(future)
[01:28:08.380]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.380]                 }
[01:28:08.380]             }
[01:28:08.380]         }
[01:28:08.380]     })
[01:28:08.380]     if (TRUE) {
[01:28:08.380]         base::sink(type = "output", split = FALSE)
[01:28:08.380]         if (TRUE) {
[01:28:08.380]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.380]         }
[01:28:08.380]         else {
[01:28:08.380]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.380]         }
[01:28:08.380]         base::close(...future.stdout)
[01:28:08.380]         ...future.stdout <- NULL
[01:28:08.380]     }
[01:28:08.380]     ...future.result$conditions <- ...future.conditions
[01:28:08.380]     ...future.result$finished <- base::Sys.time()
[01:28:08.380]     ...future.result
[01:28:08.380] }
[01:28:08.383] plan(): Setting new future strategy stack:
[01:28:08.384] List of future strategies:
[01:28:08.384] 1. sequential:
[01:28:08.384]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.384]    - tweaked: FALSE
[01:28:08.384]    - call: NULL
[01:28:08.384] plan(): nbrOfWorkers() = 1
[01:28:08.385] plan(): Setting new future strategy stack:
[01:28:08.386] List of future strategies:
[01:28:08.386] 1. sequential:
[01:28:08.386]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.386]    - tweaked: FALSE
[01:28:08.386]    - call: plan(strategy)
[01:28:08.386] plan(): nbrOfWorkers() = 1
[01:28:08.386] SequentialFuture started (and completed)
[01:28:08.387] - Launch lazy future ... done
[01:28:08.387] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.387] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.387] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.388] - globals found: [3] '+', 'value', 'a'
[01:28:08.389] Searching for globals ... DONE
[01:28:08.389] Resolving globals: TRUE
[01:28:08.389] Resolving any globals that are futures ...
[01:28:08.389] - globals: [3] '+', 'value', 'a'
[01:28:08.389] Resolving any globals that are futures ... DONE
[01:28:08.390] Resolving futures part of globals (recursively) ...
[01:28:08.390] resolve() on list ...
[01:28:08.390]  recursive: 99
[01:28:08.390]  length: 1
[01:28:08.390]  elements: 'a'
[01:28:08.391] resolved() for 'SequentialFuture' ...
[01:28:08.391] - state: 'finished'
[01:28:08.391] - run: TRUE
[01:28:08.391] - result: 'FutureResult'
[01:28:08.391] resolved() for 'SequentialFuture' ... done
[01:28:08.392] Future #1
[01:28:08.392] resolved() for 'SequentialFuture' ...
[01:28:08.392] - state: 'finished'
[01:28:08.392] - run: TRUE
[01:28:08.392] - result: 'FutureResult'
[01:28:08.393] resolved() for 'SequentialFuture' ... done
[01:28:08.393] A SequentialFuture was resolved
[01:28:08.393]  length: 0 (resolved future 1)
[01:28:08.393] resolve() on list ... DONE
[01:28:08.393] - globals: [1] 'a'
[01:28:08.393] Resolving futures part of globals (recursively) ... DONE
[01:28:08.396] The total size of the 1 globals is 1.56 MiB (1638144 bytes)
[01:28:08.397] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.56 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.56 MiB of class 'environment')
[01:28:08.397] - globals: [1] 'a'
[01:28:08.397] - packages: [1] 'future'
[01:28:08.398] getGlobalsAndPackages() ... DONE
[01:28:08.398] run() for 'Future' ...
[01:28:08.398] - state: 'created'
[01:28:08.398] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.399] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.399] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.399]   - Field: 'label'
[01:28:08.399]   - Field: 'local'
[01:28:08.399]   - Field: 'owner'
[01:28:08.400]   - Field: 'envir'
[01:28:08.400]   - Field: 'packages'
[01:28:08.400]   - Field: 'gc'
[01:28:08.400]   - Field: 'conditions'
[01:28:08.400]   - Field: 'expr'
[01:28:08.401]   - Field: 'uuid'
[01:28:08.401]   - Field: 'seed'
[01:28:08.401]   - Field: 'version'
[01:28:08.401]   - Field: 'result'
[01:28:08.401]   - Field: 'asynchronous'
[01:28:08.401]   - Field: 'calls'
[01:28:08.402]   - Field: 'globals'
[01:28:08.402]   - Field: 'stdout'
[01:28:08.402]   - Field: 'earlySignal'
[01:28:08.402]   - Field: 'lazy'
[01:28:08.402]   - Field: 'state'
[01:28:08.402] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.403] - Launch lazy future ...
[01:28:08.403] Packages needed by the future expression (n = 1): 'future'
[01:28:08.403] Packages needed by future strategies (n = 0): <none>
[01:28:08.404] {
[01:28:08.404]     {
[01:28:08.404]         {
[01:28:08.404]             ...future.startTime <- base::Sys.time()
[01:28:08.404]             {
[01:28:08.404]                 {
[01:28:08.404]                   {
[01:28:08.404]                     {
[01:28:08.404]                       base::local({
[01:28:08.404]                         has_future <- base::requireNamespace("future", 
[01:28:08.404]                           quietly = TRUE)
[01:28:08.404]                         if (has_future) {
[01:28:08.404]                           ns <- base::getNamespace("future")
[01:28:08.404]                           version <- ns[[".package"]][["version"]]
[01:28:08.404]                           if (is.null(version)) 
[01:28:08.404]                             version <- utils::packageVersion("future")
[01:28:08.404]                         }
[01:28:08.404]                         else {
[01:28:08.404]                           version <- NULL
[01:28:08.404]                         }
[01:28:08.404]                         if (!has_future || version < "1.8.0") {
[01:28:08.404]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.404]                             "", base::R.version$version.string), 
[01:28:08.404]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.404]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.404]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.404]                               "release", "version")], collapse = " "), 
[01:28:08.404]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.404]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.404]                             info)
[01:28:08.404]                           info <- base::paste(info, collapse = "; ")
[01:28:08.404]                           if (!has_future) {
[01:28:08.404]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.404]                               info)
[01:28:08.404]                           }
[01:28:08.404]                           else {
[01:28:08.404]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.404]                               info, version)
[01:28:08.404]                           }
[01:28:08.404]                           base::stop(msg)
[01:28:08.404]                         }
[01:28:08.404]                       })
[01:28:08.404]                     }
[01:28:08.404]                     base::local({
[01:28:08.404]                       for (pkg in "future") {
[01:28:08.404]                         base::loadNamespace(pkg)
[01:28:08.404]                         base::library(pkg, character.only = TRUE)
[01:28:08.404]                       }
[01:28:08.404]                     })
[01:28:08.404]                   }
[01:28:08.404]                   options(future.plan = NULL)
[01:28:08.404]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.404]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.404]                 }
[01:28:08.404]                 ...future.workdir <- getwd()
[01:28:08.404]             }
[01:28:08.404]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.404]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.404]         }
[01:28:08.404]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.404]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.404]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.404]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.404]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.404]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.404]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.404]             base::names(...future.oldOptions))
[01:28:08.404]     }
[01:28:08.404]     if (FALSE) {
[01:28:08.404]     }
[01:28:08.404]     else {
[01:28:08.404]         if (TRUE) {
[01:28:08.404]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.404]                 open = "w")
[01:28:08.404]         }
[01:28:08.404]         else {
[01:28:08.404]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.404]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.404]         }
[01:28:08.404]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.404]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.404]             base::sink(type = "output", split = FALSE)
[01:28:08.404]             base::close(...future.stdout)
[01:28:08.404]         }, add = TRUE)
[01:28:08.404]     }
[01:28:08.404]     ...future.frame <- base::sys.nframe()
[01:28:08.404]     ...future.conditions <- base::list()
[01:28:08.404]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.404]     if (FALSE) {
[01:28:08.404]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.404]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.404]     }
[01:28:08.404]     ...future.result <- base::tryCatch({
[01:28:08.404]         base::withCallingHandlers({
[01:28:08.404]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.404]                 1))
[01:28:08.404]             future::FutureResult(value = ...future.value$value, 
[01:28:08.404]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.404]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.404]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.404]                     ...future.globalenv.names))
[01:28:08.404]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.404]         }, condition = base::local({
[01:28:08.404]             c <- base::c
[01:28:08.404]             inherits <- base::inherits
[01:28:08.404]             invokeRestart <- base::invokeRestart
[01:28:08.404]             length <- base::length
[01:28:08.404]             list <- base::list
[01:28:08.404]             seq.int <- base::seq.int
[01:28:08.404]             signalCondition <- base::signalCondition
[01:28:08.404]             sys.calls <- base::sys.calls
[01:28:08.404]             `[[` <- base::`[[`
[01:28:08.404]             `+` <- base::`+`
[01:28:08.404]             `<<-` <- base::`<<-`
[01:28:08.404]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.404]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.404]                   3L)]
[01:28:08.404]             }
[01:28:08.404]             function(cond) {
[01:28:08.404]                 is_error <- inherits(cond, "error")
[01:28:08.404]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.404]                   NULL)
[01:28:08.404]                 if (is_error) {
[01:28:08.404]                   sessionInformation <- function() {
[01:28:08.404]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.404]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.404]                       search = base::search(), system = base::Sys.info())
[01:28:08.404]                   }
[01:28:08.404]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.404]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.404]                     cond$call), session = sessionInformation(), 
[01:28:08.404]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.404]                   signalCondition(cond)
[01:28:08.404]                 }
[01:28:08.404]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.404]                 "immediateCondition"))) {
[01:28:08.404]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.404]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.404]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.404]                   if (TRUE && !signal) {
[01:28:08.404]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.404]                     {
[01:28:08.404]                       inherits <- base::inherits
[01:28:08.404]                       invokeRestart <- base::invokeRestart
[01:28:08.404]                       is.null <- base::is.null
[01:28:08.404]                       muffled <- FALSE
[01:28:08.404]                       if (inherits(cond, "message")) {
[01:28:08.404]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.404]                         if (muffled) 
[01:28:08.404]                           invokeRestart("muffleMessage")
[01:28:08.404]                       }
[01:28:08.404]                       else if (inherits(cond, "warning")) {
[01:28:08.404]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.404]                         if (muffled) 
[01:28:08.404]                           invokeRestart("muffleWarning")
[01:28:08.404]                       }
[01:28:08.404]                       else if (inherits(cond, "condition")) {
[01:28:08.404]                         if (!is.null(pattern)) {
[01:28:08.404]                           computeRestarts <- base::computeRestarts
[01:28:08.404]                           grepl <- base::grepl
[01:28:08.404]                           restarts <- computeRestarts(cond)
[01:28:08.404]                           for (restart in restarts) {
[01:28:08.404]                             name <- restart$name
[01:28:08.404]                             if (is.null(name)) 
[01:28:08.404]                               next
[01:28:08.404]                             if (!grepl(pattern, name)) 
[01:28:08.404]                               next
[01:28:08.404]                             invokeRestart(restart)
[01:28:08.404]                             muffled <- TRUE
[01:28:08.404]                             break
[01:28:08.404]                           }
[01:28:08.404]                         }
[01:28:08.404]                       }
[01:28:08.404]                       invisible(muffled)
[01:28:08.404]                     }
[01:28:08.404]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.404]                   }
[01:28:08.404]                 }
[01:28:08.404]                 else {
[01:28:08.404]                   if (TRUE) {
[01:28:08.404]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.404]                     {
[01:28:08.404]                       inherits <- base::inherits
[01:28:08.404]                       invokeRestart <- base::invokeRestart
[01:28:08.404]                       is.null <- base::is.null
[01:28:08.404]                       muffled <- FALSE
[01:28:08.404]                       if (inherits(cond, "message")) {
[01:28:08.404]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.404]                         if (muffled) 
[01:28:08.404]                           invokeRestart("muffleMessage")
[01:28:08.404]                       }
[01:28:08.404]                       else if (inherits(cond, "warning")) {
[01:28:08.404]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.404]                         if (muffled) 
[01:28:08.404]                           invokeRestart("muffleWarning")
[01:28:08.404]                       }
[01:28:08.404]                       else if (inherits(cond, "condition")) {
[01:28:08.404]                         if (!is.null(pattern)) {
[01:28:08.404]                           computeRestarts <- base::computeRestarts
[01:28:08.404]                           grepl <- base::grepl
[01:28:08.404]                           restarts <- computeRestarts(cond)
[01:28:08.404]                           for (restart in restarts) {
[01:28:08.404]                             name <- restart$name
[01:28:08.404]                             if (is.null(name)) 
[01:28:08.404]                               next
[01:28:08.404]                             if (!grepl(pattern, name)) 
[01:28:08.404]                               next
[01:28:08.404]                             invokeRestart(restart)
[01:28:08.404]                             muffled <- TRUE
[01:28:08.404]                             break
[01:28:08.404]                           }
[01:28:08.404]                         }
[01:28:08.404]                       }
[01:28:08.404]                       invisible(muffled)
[01:28:08.404]                     }
[01:28:08.404]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.404]                   }
[01:28:08.404]                 }
[01:28:08.404]             }
[01:28:08.404]         }))
[01:28:08.404]     }, error = function(ex) {
[01:28:08.404]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.404]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.404]                 ...future.rng), started = ...future.startTime, 
[01:28:08.404]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.404]             version = "1.8"), class = "FutureResult")
[01:28:08.404]     }, finally = {
[01:28:08.404]         if (!identical(...future.workdir, getwd())) 
[01:28:08.404]             setwd(...future.workdir)
[01:28:08.404]         {
[01:28:08.404]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.404]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.404]             }
[01:28:08.404]             base::options(...future.oldOptions)
[01:28:08.404]             if (.Platform$OS.type == "windows") {
[01:28:08.404]                 old_names <- names(...future.oldEnvVars)
[01:28:08.404]                 envs <- base::Sys.getenv()
[01:28:08.404]                 names <- names(envs)
[01:28:08.404]                 common <- intersect(names, old_names)
[01:28:08.404]                 added <- setdiff(names, old_names)
[01:28:08.404]                 removed <- setdiff(old_names, names)
[01:28:08.404]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.404]                   envs[common]]
[01:28:08.404]                 NAMES <- toupper(changed)
[01:28:08.404]                 args <- list()
[01:28:08.404]                 for (kk in seq_along(NAMES)) {
[01:28:08.404]                   name <- changed[[kk]]
[01:28:08.404]                   NAME <- NAMES[[kk]]
[01:28:08.404]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.404]                     next
[01:28:08.404]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.404]                 }
[01:28:08.404]                 NAMES <- toupper(added)
[01:28:08.404]                 for (kk in seq_along(NAMES)) {
[01:28:08.404]                   name <- added[[kk]]
[01:28:08.404]                   NAME <- NAMES[[kk]]
[01:28:08.404]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.404]                     next
[01:28:08.404]                   args[[name]] <- ""
[01:28:08.404]                 }
[01:28:08.404]                 NAMES <- toupper(removed)
[01:28:08.404]                 for (kk in seq_along(NAMES)) {
[01:28:08.404]                   name <- removed[[kk]]
[01:28:08.404]                   NAME <- NAMES[[kk]]
[01:28:08.404]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.404]                     next
[01:28:08.404]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.404]                 }
[01:28:08.404]                 if (length(args) > 0) 
[01:28:08.404]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.404]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.404]             }
[01:28:08.404]             else {
[01:28:08.404]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.404]             }
[01:28:08.404]             {
[01:28:08.404]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.404]                   0L) {
[01:28:08.404]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.404]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.404]                   base::options(opts)
[01:28:08.404]                 }
[01:28:08.404]                 {
[01:28:08.404]                   {
[01:28:08.404]                     NULL
[01:28:08.404]                     RNGkind("Mersenne-Twister")
[01:28:08.404]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.404]                       inherits = FALSE)
[01:28:08.404]                   }
[01:28:08.404]                   options(future.plan = NULL)
[01:28:08.404]                   if (is.na(NA_character_)) 
[01:28:08.404]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.404]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.404]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.404]                   {
[01:28:08.404]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.404]                     if (!future$lazy) 
[01:28:08.404]                       future <- run(future)
[01:28:08.404]                     invisible(future)
[01:28:08.404]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.404]                 }
[01:28:08.404]             }
[01:28:08.404]         }
[01:28:08.404]     })
[01:28:08.404]     if (TRUE) {
[01:28:08.404]         base::sink(type = "output", split = FALSE)
[01:28:08.404]         if (TRUE) {
[01:28:08.404]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.404]         }
[01:28:08.404]         else {
[01:28:08.404]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.404]         }
[01:28:08.404]         base::close(...future.stdout)
[01:28:08.404]         ...future.stdout <- NULL
[01:28:08.404]     }
[01:28:08.404]     ...future.result$conditions <- ...future.conditions
[01:28:08.404]     ...future.result$finished <- base::Sys.time()
[01:28:08.404]     ...future.result
[01:28:08.404] }
[01:28:08.407] assign_globals() ...
[01:28:08.408] List of 1
[01:28:08.408]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d6dbadb8> 
[01:28:08.408]  - attr(*, "where")=List of 1
[01:28:08.408]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.408]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.408]  - attr(*, "resolved")= logi TRUE
[01:28:08.408]  - attr(*, "total_size")= num 1638144
[01:28:08.408]  - attr(*, "already-done")= logi TRUE
[01:28:08.411] - copied 'a' to environment
[01:28:08.411] assign_globals() ... done
[01:28:08.411] plan(): Setting new future strategy stack:
[01:28:08.411] List of future strategies:
[01:28:08.411] 1. sequential:
[01:28:08.411]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.411]    - tweaked: FALSE
[01:28:08.411]    - call: NULL
[01:28:08.412] plan(): nbrOfWorkers() = 1
[01:28:08.413] plan(): Setting new future strategy stack:
[01:28:08.413] List of future strategies:
[01:28:08.413] 1. sequential:
[01:28:08.413]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.413]    - tweaked: FALSE
[01:28:08.413]    - call: plan(strategy)
[01:28:08.414] plan(): nbrOfWorkers() = 1
[01:28:08.414] SequentialFuture started (and completed)
[01:28:08.415] - Launch lazy future ... done
[01:28:08.415] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.415] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.416] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.416] 
[01:28:08.416] Searching for globals ... DONE
[01:28:08.418] - globals: [0] <none>
[01:28:08.418] getGlobalsAndPackages() ... DONE
[01:28:08.419] run() for 'Future' ...
[01:28:08.419] - state: 'created'
[01:28:08.419] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.420] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.420] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.420]   - Field: 'label'
[01:28:08.420]   - Field: 'local'
[01:28:08.420]   - Field: 'owner'
[01:28:08.420]   - Field: 'envir'
[01:28:08.421]   - Field: 'packages'
[01:28:08.421]   - Field: 'gc'
[01:28:08.421]   - Field: 'conditions'
[01:28:08.421]   - Field: 'expr'
[01:28:08.421]   - Field: 'uuid'
[01:28:08.422]   - Field: 'seed'
[01:28:08.422]   - Field: 'version'
[01:28:08.422]   - Field: 'result'
[01:28:08.422]   - Field: 'asynchronous'
[01:28:08.422]   - Field: 'calls'
[01:28:08.422]   - Field: 'globals'
[01:28:08.423]   - Field: 'stdout'
[01:28:08.423]   - Field: 'earlySignal'
[01:28:08.423]   - Field: 'lazy'
[01:28:08.423]   - Field: 'state'
[01:28:08.423] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.423] - Launch lazy future ...
[01:28:08.424] Packages needed by the future expression (n = 0): <none>
[01:28:08.424] Packages needed by future strategies (n = 0): <none>
[01:28:08.424] {
[01:28:08.424]     {
[01:28:08.424]         {
[01:28:08.424]             ...future.startTime <- base::Sys.time()
[01:28:08.424]             {
[01:28:08.424]                 {
[01:28:08.424]                   {
[01:28:08.424]                     base::local({
[01:28:08.424]                       has_future <- base::requireNamespace("future", 
[01:28:08.424]                         quietly = TRUE)
[01:28:08.424]                       if (has_future) {
[01:28:08.424]                         ns <- base::getNamespace("future")
[01:28:08.424]                         version <- ns[[".package"]][["version"]]
[01:28:08.424]                         if (is.null(version)) 
[01:28:08.424]                           version <- utils::packageVersion("future")
[01:28:08.424]                       }
[01:28:08.424]                       else {
[01:28:08.424]                         version <- NULL
[01:28:08.424]                       }
[01:28:08.424]                       if (!has_future || version < "1.8.0") {
[01:28:08.424]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.424]                           "", base::R.version$version.string), 
[01:28:08.424]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.424]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.424]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.424]                             "release", "version")], collapse = " "), 
[01:28:08.424]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.424]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.424]                           info)
[01:28:08.424]                         info <- base::paste(info, collapse = "; ")
[01:28:08.424]                         if (!has_future) {
[01:28:08.424]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.424]                             info)
[01:28:08.424]                         }
[01:28:08.424]                         else {
[01:28:08.424]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.424]                             info, version)
[01:28:08.424]                         }
[01:28:08.424]                         base::stop(msg)
[01:28:08.424]                       }
[01:28:08.424]                     })
[01:28:08.424]                   }
[01:28:08.424]                   options(future.plan = NULL)
[01:28:08.424]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.424]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.424]                 }
[01:28:08.424]                 ...future.workdir <- getwd()
[01:28:08.424]             }
[01:28:08.424]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.424]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.424]         }
[01:28:08.424]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.424]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.424]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.424]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.424]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.424]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.424]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.424]             base::names(...future.oldOptions))
[01:28:08.424]     }
[01:28:08.424]     if (FALSE) {
[01:28:08.424]     }
[01:28:08.424]     else {
[01:28:08.424]         if (TRUE) {
[01:28:08.424]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.424]                 open = "w")
[01:28:08.424]         }
[01:28:08.424]         else {
[01:28:08.424]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.424]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.424]         }
[01:28:08.424]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.424]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.424]             base::sink(type = "output", split = FALSE)
[01:28:08.424]             base::close(...future.stdout)
[01:28:08.424]         }, add = TRUE)
[01:28:08.424]     }
[01:28:08.424]     ...future.frame <- base::sys.nframe()
[01:28:08.424]     ...future.conditions <- base::list()
[01:28:08.424]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.424]     if (FALSE) {
[01:28:08.424]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.424]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.424]     }
[01:28:08.424]     ...future.result <- base::tryCatch({
[01:28:08.424]         base::withCallingHandlers({
[01:28:08.424]             ...future.value <- base::withVisible(base::local(1))
[01:28:08.424]             future::FutureResult(value = ...future.value$value, 
[01:28:08.424]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.424]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.424]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.424]                     ...future.globalenv.names))
[01:28:08.424]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.424]         }, condition = base::local({
[01:28:08.424]             c <- base::c
[01:28:08.424]             inherits <- base::inherits
[01:28:08.424]             invokeRestart <- base::invokeRestart
[01:28:08.424]             length <- base::length
[01:28:08.424]             list <- base::list
[01:28:08.424]             seq.int <- base::seq.int
[01:28:08.424]             signalCondition <- base::signalCondition
[01:28:08.424]             sys.calls <- base::sys.calls
[01:28:08.424]             `[[` <- base::`[[`
[01:28:08.424]             `+` <- base::`+`
[01:28:08.424]             `<<-` <- base::`<<-`
[01:28:08.424]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.424]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.424]                   3L)]
[01:28:08.424]             }
[01:28:08.424]             function(cond) {
[01:28:08.424]                 is_error <- inherits(cond, "error")
[01:28:08.424]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.424]                   NULL)
[01:28:08.424]                 if (is_error) {
[01:28:08.424]                   sessionInformation <- function() {
[01:28:08.424]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.424]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.424]                       search = base::search(), system = base::Sys.info())
[01:28:08.424]                   }
[01:28:08.424]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.424]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.424]                     cond$call), session = sessionInformation(), 
[01:28:08.424]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.424]                   signalCondition(cond)
[01:28:08.424]                 }
[01:28:08.424]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.424]                 "immediateCondition"))) {
[01:28:08.424]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.424]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.424]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.424]                   if (TRUE && !signal) {
[01:28:08.424]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.424]                     {
[01:28:08.424]                       inherits <- base::inherits
[01:28:08.424]                       invokeRestart <- base::invokeRestart
[01:28:08.424]                       is.null <- base::is.null
[01:28:08.424]                       muffled <- FALSE
[01:28:08.424]                       if (inherits(cond, "message")) {
[01:28:08.424]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.424]                         if (muffled) 
[01:28:08.424]                           invokeRestart("muffleMessage")
[01:28:08.424]                       }
[01:28:08.424]                       else if (inherits(cond, "warning")) {
[01:28:08.424]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.424]                         if (muffled) 
[01:28:08.424]                           invokeRestart("muffleWarning")
[01:28:08.424]                       }
[01:28:08.424]                       else if (inherits(cond, "condition")) {
[01:28:08.424]                         if (!is.null(pattern)) {
[01:28:08.424]                           computeRestarts <- base::computeRestarts
[01:28:08.424]                           grepl <- base::grepl
[01:28:08.424]                           restarts <- computeRestarts(cond)
[01:28:08.424]                           for (restart in restarts) {
[01:28:08.424]                             name <- restart$name
[01:28:08.424]                             if (is.null(name)) 
[01:28:08.424]                               next
[01:28:08.424]                             if (!grepl(pattern, name)) 
[01:28:08.424]                               next
[01:28:08.424]                             invokeRestart(restart)
[01:28:08.424]                             muffled <- TRUE
[01:28:08.424]                             break
[01:28:08.424]                           }
[01:28:08.424]                         }
[01:28:08.424]                       }
[01:28:08.424]                       invisible(muffled)
[01:28:08.424]                     }
[01:28:08.424]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.424]                   }
[01:28:08.424]                 }
[01:28:08.424]                 else {
[01:28:08.424]                   if (TRUE) {
[01:28:08.424]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.424]                     {
[01:28:08.424]                       inherits <- base::inherits
[01:28:08.424]                       invokeRestart <- base::invokeRestart
[01:28:08.424]                       is.null <- base::is.null
[01:28:08.424]                       muffled <- FALSE
[01:28:08.424]                       if (inherits(cond, "message")) {
[01:28:08.424]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.424]                         if (muffled) 
[01:28:08.424]                           invokeRestart("muffleMessage")
[01:28:08.424]                       }
[01:28:08.424]                       else if (inherits(cond, "warning")) {
[01:28:08.424]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.424]                         if (muffled) 
[01:28:08.424]                           invokeRestart("muffleWarning")
[01:28:08.424]                       }
[01:28:08.424]                       else if (inherits(cond, "condition")) {
[01:28:08.424]                         if (!is.null(pattern)) {
[01:28:08.424]                           computeRestarts <- base::computeRestarts
[01:28:08.424]                           grepl <- base::grepl
[01:28:08.424]                           restarts <- computeRestarts(cond)
[01:28:08.424]                           for (restart in restarts) {
[01:28:08.424]                             name <- restart$name
[01:28:08.424]                             if (is.null(name)) 
[01:28:08.424]                               next
[01:28:08.424]                             if (!grepl(pattern, name)) 
[01:28:08.424]                               next
[01:28:08.424]                             invokeRestart(restart)
[01:28:08.424]                             muffled <- TRUE
[01:28:08.424]                             break
[01:28:08.424]                           }
[01:28:08.424]                         }
[01:28:08.424]                       }
[01:28:08.424]                       invisible(muffled)
[01:28:08.424]                     }
[01:28:08.424]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.424]                   }
[01:28:08.424]                 }
[01:28:08.424]             }
[01:28:08.424]         }))
[01:28:08.424]     }, error = function(ex) {
[01:28:08.424]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.424]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.424]                 ...future.rng), started = ...future.startTime, 
[01:28:08.424]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.424]             version = "1.8"), class = "FutureResult")
[01:28:08.424]     }, finally = {
[01:28:08.424]         if (!identical(...future.workdir, getwd())) 
[01:28:08.424]             setwd(...future.workdir)
[01:28:08.424]         {
[01:28:08.424]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.424]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.424]             }
[01:28:08.424]             base::options(...future.oldOptions)
[01:28:08.424]             if (.Platform$OS.type == "windows") {
[01:28:08.424]                 old_names <- names(...future.oldEnvVars)
[01:28:08.424]                 envs <- base::Sys.getenv()
[01:28:08.424]                 names <- names(envs)
[01:28:08.424]                 common <- intersect(names, old_names)
[01:28:08.424]                 added <- setdiff(names, old_names)
[01:28:08.424]                 removed <- setdiff(old_names, names)
[01:28:08.424]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.424]                   envs[common]]
[01:28:08.424]                 NAMES <- toupper(changed)
[01:28:08.424]                 args <- list()
[01:28:08.424]                 for (kk in seq_along(NAMES)) {
[01:28:08.424]                   name <- changed[[kk]]
[01:28:08.424]                   NAME <- NAMES[[kk]]
[01:28:08.424]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.424]                     next
[01:28:08.424]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.424]                 }
[01:28:08.424]                 NAMES <- toupper(added)
[01:28:08.424]                 for (kk in seq_along(NAMES)) {
[01:28:08.424]                   name <- added[[kk]]
[01:28:08.424]                   NAME <- NAMES[[kk]]
[01:28:08.424]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.424]                     next
[01:28:08.424]                   args[[name]] <- ""
[01:28:08.424]                 }
[01:28:08.424]                 NAMES <- toupper(removed)
[01:28:08.424]                 for (kk in seq_along(NAMES)) {
[01:28:08.424]                   name <- removed[[kk]]
[01:28:08.424]                   NAME <- NAMES[[kk]]
[01:28:08.424]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.424]                     next
[01:28:08.424]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.424]                 }
[01:28:08.424]                 if (length(args) > 0) 
[01:28:08.424]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.424]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.424]             }
[01:28:08.424]             else {
[01:28:08.424]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.424]             }
[01:28:08.424]             {
[01:28:08.424]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.424]                   0L) {
[01:28:08.424]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.424]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.424]                   base::options(opts)
[01:28:08.424]                 }
[01:28:08.424]                 {
[01:28:08.424]                   {
[01:28:08.424]                     NULL
[01:28:08.424]                     RNGkind("Mersenne-Twister")
[01:28:08.424]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.424]                       inherits = FALSE)
[01:28:08.424]                   }
[01:28:08.424]                   options(future.plan = NULL)
[01:28:08.424]                   if (is.na(NA_character_)) 
[01:28:08.424]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.424]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.424]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.424]                   {
[01:28:08.424]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.424]                     if (!future$lazy) 
[01:28:08.424]                       future <- run(future)
[01:28:08.424]                     invisible(future)
[01:28:08.424]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.424]                 }
[01:28:08.424]             }
[01:28:08.424]         }
[01:28:08.424]     })
[01:28:08.424]     if (TRUE) {
[01:28:08.424]         base::sink(type = "output", split = FALSE)
[01:28:08.424]         if (TRUE) {
[01:28:08.424]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.424]         }
[01:28:08.424]         else {
[01:28:08.424]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.424]         }
[01:28:08.424]         base::close(...future.stdout)
[01:28:08.424]         ...future.stdout <- NULL
[01:28:08.424]     }
[01:28:08.424]     ...future.result$conditions <- ...future.conditions
[01:28:08.424]     ...future.result$finished <- base::Sys.time()
[01:28:08.424]     ...future.result
[01:28:08.424] }
[01:28:08.428] plan(): Setting new future strategy stack:
[01:28:08.429] List of future strategies:
[01:28:08.429] 1. sequential:
[01:28:08.429]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.429]    - tweaked: FALSE
[01:28:08.429]    - call: NULL
[01:28:08.429] plan(): nbrOfWorkers() = 1
[01:28:08.430] plan(): Setting new future strategy stack:
[01:28:08.431] List of future strategies:
[01:28:08.431] 1. sequential:
[01:28:08.431]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.431]    - tweaked: FALSE
[01:28:08.431]    - call: plan(strategy)
[01:28:08.431] plan(): nbrOfWorkers() = 1
[01:28:08.431] SequentialFuture started (and completed)
[01:28:08.432] - Launch lazy future ... done
[01:28:08.432] run() for 'SequentialFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.432] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.433] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.434] - globals found: [3] '+', 'value', 'a'
[01:28:08.435] Searching for globals ... DONE
[01:28:08.435] Resolving globals: TRUE
[01:28:08.435] Resolving any globals that are futures ...
[01:28:08.435] - globals: [3] '+', 'value', 'a'
[01:28:08.435] Resolving any globals that are futures ... DONE
[01:28:08.436] Resolving futures part of globals (recursively) ...
[01:28:08.436] resolve() on list ...
[01:28:08.436]  recursive: 99
[01:28:08.436]  length: 1
[01:28:08.437]  elements: 'a'
[01:28:08.437] resolved() for 'SequentialFuture' ...
[01:28:08.437] - state: 'finished'
[01:28:08.437] - run: TRUE
[01:28:08.437] - result: 'FutureResult'
[01:28:08.438] resolved() for 'SequentialFuture' ... done
[01:28:08.438] Future #1
[01:28:08.438] resolved() for 'SequentialFuture' ...
[01:28:08.438] - state: 'finished'
[01:28:08.438] - run: TRUE
[01:28:08.439] - result: 'FutureResult'
[01:28:08.439] resolved() for 'SequentialFuture' ... done
[01:28:08.439] A SequentialFuture was resolved
[01:28:08.439]  length: 0 (resolved future 1)
[01:28:08.439] resolve() on list ... DONE
[01:28:08.439] - globals: [1] 'a'
[01:28:08.440] Resolving futures part of globals (recursively) ... DONE
[01:28:08.442] The total size of the 1 globals is 1.56 MiB (1638144 bytes)
[01:28:08.442] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.56 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.56 MiB of class 'environment')
[01:28:08.443] - globals: [1] 'a'
[01:28:08.443] - packages: [1] 'future'
[01:28:08.443] getGlobalsAndPackages() ... DONE
[01:28:08.443] run() for 'Future' ...
[01:28:08.443] - state: 'created'
[01:28:08.444] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.444] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.444] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.444]   - Field: 'label'
[01:28:08.445]   - Field: 'local'
[01:28:08.445]   - Field: 'owner'
[01:28:08.445]   - Field: 'envir'
[01:28:08.445]   - Field: 'packages'
[01:28:08.445]   - Field: 'gc'
[01:28:08.445]   - Field: 'conditions'
[01:28:08.446]   - Field: 'expr'
[01:28:08.446]   - Field: 'uuid'
[01:28:08.446]   - Field: 'seed'
[01:28:08.446]   - Field: 'version'
[01:28:08.446]   - Field: 'result'
[01:28:08.447]   - Field: 'asynchronous'
[01:28:08.447]   - Field: 'calls'
[01:28:08.447]   - Field: 'globals'
[01:28:08.447]   - Field: 'stdout'
[01:28:08.447]   - Field: 'earlySignal'
[01:28:08.447]   - Field: 'lazy'
[01:28:08.448]   - Field: 'state'
[01:28:08.448] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.448] - Launch lazy future ...
[01:28:08.448] Packages needed by the future expression (n = 1): 'future'
[01:28:08.448] Packages needed by future strategies (n = 0): <none>
[01:28:08.449] {
[01:28:08.449]     {
[01:28:08.449]         {
[01:28:08.449]             ...future.startTime <- base::Sys.time()
[01:28:08.449]             {
[01:28:08.449]                 {
[01:28:08.449]                   {
[01:28:08.449]                     {
[01:28:08.449]                       base::local({
[01:28:08.449]                         has_future <- base::requireNamespace("future", 
[01:28:08.449]                           quietly = TRUE)
[01:28:08.449]                         if (has_future) {
[01:28:08.449]                           ns <- base::getNamespace("future")
[01:28:08.449]                           version <- ns[[".package"]][["version"]]
[01:28:08.449]                           if (is.null(version)) 
[01:28:08.449]                             version <- utils::packageVersion("future")
[01:28:08.449]                         }
[01:28:08.449]                         else {
[01:28:08.449]                           version <- NULL
[01:28:08.449]                         }
[01:28:08.449]                         if (!has_future || version < "1.8.0") {
[01:28:08.449]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.449]                             "", base::R.version$version.string), 
[01:28:08.449]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.449]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.449]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.449]                               "release", "version")], collapse = " "), 
[01:28:08.449]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.449]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.449]                             info)
[01:28:08.449]                           info <- base::paste(info, collapse = "; ")
[01:28:08.449]                           if (!has_future) {
[01:28:08.449]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.449]                               info)
[01:28:08.449]                           }
[01:28:08.449]                           else {
[01:28:08.449]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.449]                               info, version)
[01:28:08.449]                           }
[01:28:08.449]                           base::stop(msg)
[01:28:08.449]                         }
[01:28:08.449]                       })
[01:28:08.449]                     }
[01:28:08.449]                     base::local({
[01:28:08.449]                       for (pkg in "future") {
[01:28:08.449]                         base::loadNamespace(pkg)
[01:28:08.449]                         base::library(pkg, character.only = TRUE)
[01:28:08.449]                       }
[01:28:08.449]                     })
[01:28:08.449]                   }
[01:28:08.449]                   options(future.plan = NULL)
[01:28:08.449]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.449]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.449]                 }
[01:28:08.449]                 ...future.workdir <- getwd()
[01:28:08.449]             }
[01:28:08.449]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.449]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.449]         }
[01:28:08.449]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.449]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.449]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.449]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.449]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.449]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.449]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.449]             base::names(...future.oldOptions))
[01:28:08.449]     }
[01:28:08.449]     if (FALSE) {
[01:28:08.449]     }
[01:28:08.449]     else {
[01:28:08.449]         if (TRUE) {
[01:28:08.449]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.449]                 open = "w")
[01:28:08.449]         }
[01:28:08.449]         else {
[01:28:08.449]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.449]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.449]         }
[01:28:08.449]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.449]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.449]             base::sink(type = "output", split = FALSE)
[01:28:08.449]             base::close(...future.stdout)
[01:28:08.449]         }, add = TRUE)
[01:28:08.449]     }
[01:28:08.449]     ...future.frame <- base::sys.nframe()
[01:28:08.449]     ...future.conditions <- base::list()
[01:28:08.449]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.449]     if (FALSE) {
[01:28:08.449]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.449]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.449]     }
[01:28:08.449]     ...future.result <- base::tryCatch({
[01:28:08.449]         base::withCallingHandlers({
[01:28:08.449]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.449]                 1))
[01:28:08.449]             future::FutureResult(value = ...future.value$value, 
[01:28:08.449]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.449]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.449]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.449]                     ...future.globalenv.names))
[01:28:08.449]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.449]         }, condition = base::local({
[01:28:08.449]             c <- base::c
[01:28:08.449]             inherits <- base::inherits
[01:28:08.449]             invokeRestart <- base::invokeRestart
[01:28:08.449]             length <- base::length
[01:28:08.449]             list <- base::list
[01:28:08.449]             seq.int <- base::seq.int
[01:28:08.449]             signalCondition <- base::signalCondition
[01:28:08.449]             sys.calls <- base::sys.calls
[01:28:08.449]             `[[` <- base::`[[`
[01:28:08.449]             `+` <- base::`+`
[01:28:08.449]             `<<-` <- base::`<<-`
[01:28:08.449]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.449]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.449]                   3L)]
[01:28:08.449]             }
[01:28:08.449]             function(cond) {
[01:28:08.449]                 is_error <- inherits(cond, "error")
[01:28:08.449]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.449]                   NULL)
[01:28:08.449]                 if (is_error) {
[01:28:08.449]                   sessionInformation <- function() {
[01:28:08.449]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.449]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.449]                       search = base::search(), system = base::Sys.info())
[01:28:08.449]                   }
[01:28:08.449]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.449]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.449]                     cond$call), session = sessionInformation(), 
[01:28:08.449]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.449]                   signalCondition(cond)
[01:28:08.449]                 }
[01:28:08.449]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.449]                 "immediateCondition"))) {
[01:28:08.449]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.449]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.449]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.449]                   if (TRUE && !signal) {
[01:28:08.449]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.449]                     {
[01:28:08.449]                       inherits <- base::inherits
[01:28:08.449]                       invokeRestart <- base::invokeRestart
[01:28:08.449]                       is.null <- base::is.null
[01:28:08.449]                       muffled <- FALSE
[01:28:08.449]                       if (inherits(cond, "message")) {
[01:28:08.449]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.449]                         if (muffled) 
[01:28:08.449]                           invokeRestart("muffleMessage")
[01:28:08.449]                       }
[01:28:08.449]                       else if (inherits(cond, "warning")) {
[01:28:08.449]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.449]                         if (muffled) 
[01:28:08.449]                           invokeRestart("muffleWarning")
[01:28:08.449]                       }
[01:28:08.449]                       else if (inherits(cond, "condition")) {
[01:28:08.449]                         if (!is.null(pattern)) {
[01:28:08.449]                           computeRestarts <- base::computeRestarts
[01:28:08.449]                           grepl <- base::grepl
[01:28:08.449]                           restarts <- computeRestarts(cond)
[01:28:08.449]                           for (restart in restarts) {
[01:28:08.449]                             name <- restart$name
[01:28:08.449]                             if (is.null(name)) 
[01:28:08.449]                               next
[01:28:08.449]                             if (!grepl(pattern, name)) 
[01:28:08.449]                               next
[01:28:08.449]                             invokeRestart(restart)
[01:28:08.449]                             muffled <- TRUE
[01:28:08.449]                             break
[01:28:08.449]                           }
[01:28:08.449]                         }
[01:28:08.449]                       }
[01:28:08.449]                       invisible(muffled)
[01:28:08.449]                     }
[01:28:08.449]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.449]                   }
[01:28:08.449]                 }
[01:28:08.449]                 else {
[01:28:08.449]                   if (TRUE) {
[01:28:08.449]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.449]                     {
[01:28:08.449]                       inherits <- base::inherits
[01:28:08.449]                       invokeRestart <- base::invokeRestart
[01:28:08.449]                       is.null <- base::is.null
[01:28:08.449]                       muffled <- FALSE
[01:28:08.449]                       if (inherits(cond, "message")) {
[01:28:08.449]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.449]                         if (muffled) 
[01:28:08.449]                           invokeRestart("muffleMessage")
[01:28:08.449]                       }
[01:28:08.449]                       else if (inherits(cond, "warning")) {
[01:28:08.449]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.449]                         if (muffled) 
[01:28:08.449]                           invokeRestart("muffleWarning")
[01:28:08.449]                       }
[01:28:08.449]                       else if (inherits(cond, "condition")) {
[01:28:08.449]                         if (!is.null(pattern)) {
[01:28:08.449]                           computeRestarts <- base::computeRestarts
[01:28:08.449]                           grepl <- base::grepl
[01:28:08.449]                           restarts <- computeRestarts(cond)
[01:28:08.449]                           for (restart in restarts) {
[01:28:08.449]                             name <- restart$name
[01:28:08.449]                             if (is.null(name)) 
[01:28:08.449]                               next
[01:28:08.449]                             if (!grepl(pattern, name)) 
[01:28:08.449]                               next
[01:28:08.449]                             invokeRestart(restart)
[01:28:08.449]                             muffled <- TRUE
[01:28:08.449]                             break
[01:28:08.449]                           }
[01:28:08.449]                         }
[01:28:08.449]                       }
[01:28:08.449]                       invisible(muffled)
[01:28:08.449]                     }
[01:28:08.449]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.449]                   }
[01:28:08.449]                 }
[01:28:08.449]             }
[01:28:08.449]         }))
[01:28:08.449]     }, error = function(ex) {
[01:28:08.449]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.449]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.449]                 ...future.rng), started = ...future.startTime, 
[01:28:08.449]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.449]             version = "1.8"), class = "FutureResult")
[01:28:08.449]     }, finally = {
[01:28:08.449]         if (!identical(...future.workdir, getwd())) 
[01:28:08.449]             setwd(...future.workdir)
[01:28:08.449]         {
[01:28:08.449]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.449]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.449]             }
[01:28:08.449]             base::options(...future.oldOptions)
[01:28:08.449]             if (.Platform$OS.type == "windows") {
[01:28:08.449]                 old_names <- names(...future.oldEnvVars)
[01:28:08.449]                 envs <- base::Sys.getenv()
[01:28:08.449]                 names <- names(envs)
[01:28:08.449]                 common <- intersect(names, old_names)
[01:28:08.449]                 added <- setdiff(names, old_names)
[01:28:08.449]                 removed <- setdiff(old_names, names)
[01:28:08.449]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.449]                   envs[common]]
[01:28:08.449]                 NAMES <- toupper(changed)
[01:28:08.449]                 args <- list()
[01:28:08.449]                 for (kk in seq_along(NAMES)) {
[01:28:08.449]                   name <- changed[[kk]]
[01:28:08.449]                   NAME <- NAMES[[kk]]
[01:28:08.449]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.449]                     next
[01:28:08.449]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.449]                 }
[01:28:08.449]                 NAMES <- toupper(added)
[01:28:08.449]                 for (kk in seq_along(NAMES)) {
[01:28:08.449]                   name <- added[[kk]]
[01:28:08.449]                   NAME <- NAMES[[kk]]
[01:28:08.449]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.449]                     next
[01:28:08.449]                   args[[name]] <- ""
[01:28:08.449]                 }
[01:28:08.449]                 NAMES <- toupper(removed)
[01:28:08.449]                 for (kk in seq_along(NAMES)) {
[01:28:08.449]                   name <- removed[[kk]]
[01:28:08.449]                   NAME <- NAMES[[kk]]
[01:28:08.449]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.449]                     next
[01:28:08.449]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.449]                 }
[01:28:08.449]                 if (length(args) > 0) 
[01:28:08.449]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.449]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.449]             }
[01:28:08.449]             else {
[01:28:08.449]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.449]             }
[01:28:08.449]             {
[01:28:08.449]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.449]                   0L) {
[01:28:08.449]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.449]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.449]                   base::options(opts)
[01:28:08.449]                 }
[01:28:08.449]                 {
[01:28:08.449]                   {
[01:28:08.449]                     NULL
[01:28:08.449]                     RNGkind("Mersenne-Twister")
[01:28:08.449]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.449]                       inherits = FALSE)
[01:28:08.449]                   }
[01:28:08.449]                   options(future.plan = NULL)
[01:28:08.449]                   if (is.na(NA_character_)) 
[01:28:08.449]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.449]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.449]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.449]                   {
[01:28:08.449]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.449]                     if (!future$lazy) 
[01:28:08.449]                       future <- run(future)
[01:28:08.449]                     invisible(future)
[01:28:08.449]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.449]                 }
[01:28:08.449]             }
[01:28:08.449]         }
[01:28:08.449]     })
[01:28:08.449]     if (TRUE) {
[01:28:08.449]         base::sink(type = "output", split = FALSE)
[01:28:08.449]         if (TRUE) {
[01:28:08.449]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.449]         }
[01:28:08.449]         else {
[01:28:08.449]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.449]         }
[01:28:08.449]         base::close(...future.stdout)
[01:28:08.449]         ...future.stdout <- NULL
[01:28:08.449]     }
[01:28:08.449]     ...future.result$conditions <- ...future.conditions
[01:28:08.449]     ...future.result$finished <- base::Sys.time()
[01:28:08.449]     ...future.result
[01:28:08.449] }
[01:28:08.453] assign_globals() ...
[01:28:08.453] List of 1
[01:28:08.453]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d86b4ed8> 
[01:28:08.453]  - attr(*, "where")=List of 1
[01:28:08.453]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.453]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.453]  - attr(*, "resolved")= logi TRUE
[01:28:08.453]  - attr(*, "total_size")= num 1638144
[01:28:08.453]  - attr(*, "already-done")= logi TRUE
[01:28:08.456] - copied 'a' to environment
[01:28:08.456] assign_globals() ... done
[01:28:08.457] plan(): Setting new future strategy stack:
[01:28:08.457] List of future strategies:
[01:28:08.457] 1. sequential:
[01:28:08.457]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.457]    - tweaked: FALSE
[01:28:08.457]    - call: NULL
[01:28:08.458] plan(): nbrOfWorkers() = 1
[01:28:08.459] plan(): Setting new future strategy stack:
[01:28:08.459] List of future strategies:
[01:28:08.459] 1. sequential:
[01:28:08.459]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.459]    - tweaked: FALSE
[01:28:08.459]    - call: plan(strategy)
[01:28:08.460] plan(): nbrOfWorkers() = 1
[01:28:08.460] SequentialFuture started (and completed)
[01:28:08.460] - Launch lazy future ... done
[01:28:08.460] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.461] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.461] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.462] 
[01:28:08.462] Searching for globals ... DONE
[01:28:08.462] - globals: [0] <none>
[01:28:08.462] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.462] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.463] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.464] - globals found: [3] '+', 'value', 'a'
[01:28:08.464] Searching for globals ... DONE
[01:28:08.464] Resolving globals: TRUE
[01:28:08.464] Resolving any globals that are futures ...
[01:28:08.464] - globals: [3] '+', 'value', 'a'
[01:28:08.465] Resolving any globals that are futures ... DONE
[01:28:08.465] Resolving futures part of globals (recursively) ...
[01:28:08.465] resolve() on list ...
[01:28:08.466]  recursive: 99
[01:28:08.466]  length: 1
[01:28:08.466]  elements: 'a'
[01:28:08.466] run() for 'Future' ...
[01:28:08.466] - state: 'created'
[01:28:08.466] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.468] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.468] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.468]   - Field: 'label'
[01:28:08.468]   - Field: 'local'
[01:28:08.468]   - Field: 'owner'
[01:28:08.469]   - Field: 'envir'
[01:28:08.469]   - Field: 'packages'
[01:28:08.469]   - Field: 'gc'
[01:28:08.469]   - Field: 'conditions'
[01:28:08.469]   - Field: 'expr'
[01:28:08.469]   - Field: 'uuid'
[01:28:08.470]   - Field: 'seed'
[01:28:08.470]   - Field: 'version'
[01:28:08.470]   - Field: 'result'
[01:28:08.470]   - Field: 'asynchronous'
[01:28:08.470]   - Field: 'calls'
[01:28:08.471]   - Field: 'globals'
[01:28:08.471]   - Field: 'stdout'
[01:28:08.471]   - Field: 'earlySignal'
[01:28:08.471]   - Field: 'lazy'
[01:28:08.471]   - Field: 'state'
[01:28:08.471] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.472] - Launch lazy future ...
[01:28:08.472] Packages needed by the future expression (n = 0): <none>
[01:28:08.472] Packages needed by future strategies (n = 0): <none>
[01:28:08.473] {
[01:28:08.473]     {
[01:28:08.473]         {
[01:28:08.473]             ...future.startTime <- base::Sys.time()
[01:28:08.473]             {
[01:28:08.473]                 {
[01:28:08.473]                   {
[01:28:08.473]                     base::local({
[01:28:08.473]                       has_future <- base::requireNamespace("future", 
[01:28:08.473]                         quietly = TRUE)
[01:28:08.473]                       if (has_future) {
[01:28:08.473]                         ns <- base::getNamespace("future")
[01:28:08.473]                         version <- ns[[".package"]][["version"]]
[01:28:08.473]                         if (is.null(version)) 
[01:28:08.473]                           version <- utils::packageVersion("future")
[01:28:08.473]                       }
[01:28:08.473]                       else {
[01:28:08.473]                         version <- NULL
[01:28:08.473]                       }
[01:28:08.473]                       if (!has_future || version < "1.8.0") {
[01:28:08.473]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.473]                           "", base::R.version$version.string), 
[01:28:08.473]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.473]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.473]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.473]                             "release", "version")], collapse = " "), 
[01:28:08.473]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.473]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.473]                           info)
[01:28:08.473]                         info <- base::paste(info, collapse = "; ")
[01:28:08.473]                         if (!has_future) {
[01:28:08.473]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.473]                             info)
[01:28:08.473]                         }
[01:28:08.473]                         else {
[01:28:08.473]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.473]                             info, version)
[01:28:08.473]                         }
[01:28:08.473]                         base::stop(msg)
[01:28:08.473]                       }
[01:28:08.473]                     })
[01:28:08.473]                   }
[01:28:08.473]                   options(future.plan = NULL)
[01:28:08.473]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.473]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.473]                 }
[01:28:08.473]                 ...future.workdir <- getwd()
[01:28:08.473]             }
[01:28:08.473]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.473]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.473]         }
[01:28:08.473]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.473]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.473]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.473]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.473]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.473]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.473]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.473]             base::names(...future.oldOptions))
[01:28:08.473]     }
[01:28:08.473]     if (FALSE) {
[01:28:08.473]     }
[01:28:08.473]     else {
[01:28:08.473]         if (TRUE) {
[01:28:08.473]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.473]                 open = "w")
[01:28:08.473]         }
[01:28:08.473]         else {
[01:28:08.473]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.473]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.473]         }
[01:28:08.473]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.473]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.473]             base::sink(type = "output", split = FALSE)
[01:28:08.473]             base::close(...future.stdout)
[01:28:08.473]         }, add = TRUE)
[01:28:08.473]     }
[01:28:08.473]     ...future.frame <- base::sys.nframe()
[01:28:08.473]     ...future.conditions <- base::list()
[01:28:08.473]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.473]     if (FALSE) {
[01:28:08.473]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.473]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.473]     }
[01:28:08.473]     ...future.result <- base::tryCatch({
[01:28:08.473]         base::withCallingHandlers({
[01:28:08.473]             ...future.value <- base::withVisible(base::local(1))
[01:28:08.473]             future::FutureResult(value = ...future.value$value, 
[01:28:08.473]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.473]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.473]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.473]                     ...future.globalenv.names))
[01:28:08.473]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.473]         }, condition = base::local({
[01:28:08.473]             c <- base::c
[01:28:08.473]             inherits <- base::inherits
[01:28:08.473]             invokeRestart <- base::invokeRestart
[01:28:08.473]             length <- base::length
[01:28:08.473]             list <- base::list
[01:28:08.473]             seq.int <- base::seq.int
[01:28:08.473]             signalCondition <- base::signalCondition
[01:28:08.473]             sys.calls <- base::sys.calls
[01:28:08.473]             `[[` <- base::`[[`
[01:28:08.473]             `+` <- base::`+`
[01:28:08.473]             `<<-` <- base::`<<-`
[01:28:08.473]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.473]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.473]                   3L)]
[01:28:08.473]             }
[01:28:08.473]             function(cond) {
[01:28:08.473]                 is_error <- inherits(cond, "error")
[01:28:08.473]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.473]                   NULL)
[01:28:08.473]                 if (is_error) {
[01:28:08.473]                   sessionInformation <- function() {
[01:28:08.473]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.473]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.473]                       search = base::search(), system = base::Sys.info())
[01:28:08.473]                   }
[01:28:08.473]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.473]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.473]                     cond$call), session = sessionInformation(), 
[01:28:08.473]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.473]                   signalCondition(cond)
[01:28:08.473]                 }
[01:28:08.473]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.473]                 "immediateCondition"))) {
[01:28:08.473]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.473]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.473]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.473]                   if (TRUE && !signal) {
[01:28:08.473]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.473]                     {
[01:28:08.473]                       inherits <- base::inherits
[01:28:08.473]                       invokeRestart <- base::invokeRestart
[01:28:08.473]                       is.null <- base::is.null
[01:28:08.473]                       muffled <- FALSE
[01:28:08.473]                       if (inherits(cond, "message")) {
[01:28:08.473]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.473]                         if (muffled) 
[01:28:08.473]                           invokeRestart("muffleMessage")
[01:28:08.473]                       }
[01:28:08.473]                       else if (inherits(cond, "warning")) {
[01:28:08.473]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.473]                         if (muffled) 
[01:28:08.473]                           invokeRestart("muffleWarning")
[01:28:08.473]                       }
[01:28:08.473]                       else if (inherits(cond, "condition")) {
[01:28:08.473]                         if (!is.null(pattern)) {
[01:28:08.473]                           computeRestarts <- base::computeRestarts
[01:28:08.473]                           grepl <- base::grepl
[01:28:08.473]                           restarts <- computeRestarts(cond)
[01:28:08.473]                           for (restart in restarts) {
[01:28:08.473]                             name <- restart$name
[01:28:08.473]                             if (is.null(name)) 
[01:28:08.473]                               next
[01:28:08.473]                             if (!grepl(pattern, name)) 
[01:28:08.473]                               next
[01:28:08.473]                             invokeRestart(restart)
[01:28:08.473]                             muffled <- TRUE
[01:28:08.473]                             break
[01:28:08.473]                           }
[01:28:08.473]                         }
[01:28:08.473]                       }
[01:28:08.473]                       invisible(muffled)
[01:28:08.473]                     }
[01:28:08.473]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.473]                   }
[01:28:08.473]                 }
[01:28:08.473]                 else {
[01:28:08.473]                   if (TRUE) {
[01:28:08.473]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.473]                     {
[01:28:08.473]                       inherits <- base::inherits
[01:28:08.473]                       invokeRestart <- base::invokeRestart
[01:28:08.473]                       is.null <- base::is.null
[01:28:08.473]                       muffled <- FALSE
[01:28:08.473]                       if (inherits(cond, "message")) {
[01:28:08.473]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.473]                         if (muffled) 
[01:28:08.473]                           invokeRestart("muffleMessage")
[01:28:08.473]                       }
[01:28:08.473]                       else if (inherits(cond, "warning")) {
[01:28:08.473]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.473]                         if (muffled) 
[01:28:08.473]                           invokeRestart("muffleWarning")
[01:28:08.473]                       }
[01:28:08.473]                       else if (inherits(cond, "condition")) {
[01:28:08.473]                         if (!is.null(pattern)) {
[01:28:08.473]                           computeRestarts <- base::computeRestarts
[01:28:08.473]                           grepl <- base::grepl
[01:28:08.473]                           restarts <- computeRestarts(cond)
[01:28:08.473]                           for (restart in restarts) {
[01:28:08.473]                             name <- restart$name
[01:28:08.473]                             if (is.null(name)) 
[01:28:08.473]                               next
[01:28:08.473]                             if (!grepl(pattern, name)) 
[01:28:08.473]                               next
[01:28:08.473]                             invokeRestart(restart)
[01:28:08.473]                             muffled <- TRUE
[01:28:08.473]                             break
[01:28:08.473]                           }
[01:28:08.473]                         }
[01:28:08.473]                       }
[01:28:08.473]                       invisible(muffled)
[01:28:08.473]                     }
[01:28:08.473]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.473]                   }
[01:28:08.473]                 }
[01:28:08.473]             }
[01:28:08.473]         }))
[01:28:08.473]     }, error = function(ex) {
[01:28:08.473]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.473]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.473]                 ...future.rng), started = ...future.startTime, 
[01:28:08.473]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.473]             version = "1.8"), class = "FutureResult")
[01:28:08.473]     }, finally = {
[01:28:08.473]         if (!identical(...future.workdir, getwd())) 
[01:28:08.473]             setwd(...future.workdir)
[01:28:08.473]         {
[01:28:08.473]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.473]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.473]             }
[01:28:08.473]             base::options(...future.oldOptions)
[01:28:08.473]             if (.Platform$OS.type == "windows") {
[01:28:08.473]                 old_names <- names(...future.oldEnvVars)
[01:28:08.473]                 envs <- base::Sys.getenv()
[01:28:08.473]                 names <- names(envs)
[01:28:08.473]                 common <- intersect(names, old_names)
[01:28:08.473]                 added <- setdiff(names, old_names)
[01:28:08.473]                 removed <- setdiff(old_names, names)
[01:28:08.473]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.473]                   envs[common]]
[01:28:08.473]                 NAMES <- toupper(changed)
[01:28:08.473]                 args <- list()
[01:28:08.473]                 for (kk in seq_along(NAMES)) {
[01:28:08.473]                   name <- changed[[kk]]
[01:28:08.473]                   NAME <- NAMES[[kk]]
[01:28:08.473]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.473]                     next
[01:28:08.473]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.473]                 }
[01:28:08.473]                 NAMES <- toupper(added)
[01:28:08.473]                 for (kk in seq_along(NAMES)) {
[01:28:08.473]                   name <- added[[kk]]
[01:28:08.473]                   NAME <- NAMES[[kk]]
[01:28:08.473]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.473]                     next
[01:28:08.473]                   args[[name]] <- ""
[01:28:08.473]                 }
[01:28:08.473]                 NAMES <- toupper(removed)
[01:28:08.473]                 for (kk in seq_along(NAMES)) {
[01:28:08.473]                   name <- removed[[kk]]
[01:28:08.473]                   NAME <- NAMES[[kk]]
[01:28:08.473]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.473]                     next
[01:28:08.473]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.473]                 }
[01:28:08.473]                 if (length(args) > 0) 
[01:28:08.473]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.473]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.473]             }
[01:28:08.473]             else {
[01:28:08.473]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.473]             }
[01:28:08.473]             {
[01:28:08.473]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.473]                   0L) {
[01:28:08.473]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.473]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.473]                   base::options(opts)
[01:28:08.473]                 }
[01:28:08.473]                 {
[01:28:08.473]                   {
[01:28:08.473]                     NULL
[01:28:08.473]                     RNGkind("Mersenne-Twister")
[01:28:08.473]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.473]                       inherits = FALSE)
[01:28:08.473]                   }
[01:28:08.473]                   options(future.plan = NULL)
[01:28:08.473]                   if (is.na(NA_character_)) 
[01:28:08.473]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.473]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.473]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.473]                   {
[01:28:08.473]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.473]                     if (!future$lazy) 
[01:28:08.473]                       future <- run(future)
[01:28:08.473]                     invisible(future)
[01:28:08.473]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.473]                 }
[01:28:08.473]             }
[01:28:08.473]         }
[01:28:08.473]     })
[01:28:08.473]     if (TRUE) {
[01:28:08.473]         base::sink(type = "output", split = FALSE)
[01:28:08.473]         if (TRUE) {
[01:28:08.473]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.473]         }
[01:28:08.473]         else {
[01:28:08.473]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.473]         }
[01:28:08.473]         base::close(...future.stdout)
[01:28:08.473]         ...future.stdout <- NULL
[01:28:08.473]     }
[01:28:08.473]     ...future.result$conditions <- ...future.conditions
[01:28:08.473]     ...future.result$finished <- base::Sys.time()
[01:28:08.473]     ...future.result
[01:28:08.473] }
[01:28:08.477] plan(): Setting new future strategy stack:
[01:28:08.477] List of future strategies:
[01:28:08.477] 1. sequential:
[01:28:08.477]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.477]    - tweaked: FALSE
[01:28:08.477]    - call: NULL
[01:28:08.477] plan(): nbrOfWorkers() = 1
[01:28:08.478] plan(): Setting new future strategy stack:
[01:28:08.479] List of future strategies:
[01:28:08.479] 1. sequential:
[01:28:08.479]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.479]    - tweaked: FALSE
[01:28:08.479]    - call: plan(strategy)
[01:28:08.479] plan(): nbrOfWorkers() = 1
[01:28:08.480] SequentialFuture started (and completed)
[01:28:08.480] - Launch lazy future ... done
[01:28:08.480] run() for 'SequentialFuture' ... done
[01:28:08.480] resolved() for 'SequentialFuture' ...
[01:28:08.480] - state: 'finished'
[01:28:08.480] - run: TRUE
[01:28:08.481] - result: 'FutureResult'
[01:28:08.481] resolved() for 'SequentialFuture' ... done
[01:28:08.481] Future #1
[01:28:08.481] resolved() for 'SequentialFuture' ...
[01:28:08.481] - state: 'finished'
[01:28:08.482] - run: TRUE
[01:28:08.482] - result: 'FutureResult'
[01:28:08.482] resolved() for 'SequentialFuture' ... done
[01:28:08.482] A SequentialFuture was resolved
[01:28:08.482]  length: 0 (resolved future 1)
[01:28:08.483] resolve() on list ... DONE
[01:28:08.483] - globals: [1] 'a'
[01:28:08.483] Resolving futures part of globals (recursively) ... DONE
[01:28:08.485] The total size of the 1 globals is 1.56 MiB (1638312 bytes)
[01:28:08.486] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.56 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.56 MiB of class 'environment')
[01:28:08.486] - globals: [1] 'a'
[01:28:08.486] - packages: [1] 'future'
[01:28:08.486] getGlobalsAndPackages() ... DONE
[01:28:08.486] run() for 'Future' ...
[01:28:08.487] - state: 'created'
[01:28:08.487] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.487] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.487] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.488]   - Field: 'label'
[01:28:08.488]   - Field: 'local'
[01:28:08.488]   - Field: 'owner'
[01:28:08.488]   - Field: 'envir'
[01:28:08.488]   - Field: 'packages'
[01:28:08.489]   - Field: 'gc'
[01:28:08.489]   - Field: 'conditions'
[01:28:08.489]   - Field: 'expr'
[01:28:08.489]   - Field: 'uuid'
[01:28:08.489]   - Field: 'seed'
[01:28:08.489]   - Field: 'version'
[01:28:08.490]   - Field: 'result'
[01:28:08.490]   - Field: 'asynchronous'
[01:28:08.490]   - Field: 'calls'
[01:28:08.490]   - Field: 'globals'
[01:28:08.490]   - Field: 'stdout'
[01:28:08.490]   - Field: 'earlySignal'
[01:28:08.491]   - Field: 'lazy'
[01:28:08.491]   - Field: 'state'
[01:28:08.491] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.491] - Launch lazy future ...
[01:28:08.491] Packages needed by the future expression (n = 1): 'future'
[01:28:08.492] Packages needed by future strategies (n = 0): <none>
[01:28:08.492] {
[01:28:08.492]     {
[01:28:08.492]         {
[01:28:08.492]             ...future.startTime <- base::Sys.time()
[01:28:08.492]             {
[01:28:08.492]                 {
[01:28:08.492]                   {
[01:28:08.492]                     {
[01:28:08.492]                       base::local({
[01:28:08.492]                         has_future <- base::requireNamespace("future", 
[01:28:08.492]                           quietly = TRUE)
[01:28:08.492]                         if (has_future) {
[01:28:08.492]                           ns <- base::getNamespace("future")
[01:28:08.492]                           version <- ns[[".package"]][["version"]]
[01:28:08.492]                           if (is.null(version)) 
[01:28:08.492]                             version <- utils::packageVersion("future")
[01:28:08.492]                         }
[01:28:08.492]                         else {
[01:28:08.492]                           version <- NULL
[01:28:08.492]                         }
[01:28:08.492]                         if (!has_future || version < "1.8.0") {
[01:28:08.492]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.492]                             "", base::R.version$version.string), 
[01:28:08.492]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.492]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.492]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.492]                               "release", "version")], collapse = " "), 
[01:28:08.492]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.492]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.492]                             info)
[01:28:08.492]                           info <- base::paste(info, collapse = "; ")
[01:28:08.492]                           if (!has_future) {
[01:28:08.492]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.492]                               info)
[01:28:08.492]                           }
[01:28:08.492]                           else {
[01:28:08.492]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.492]                               info, version)
[01:28:08.492]                           }
[01:28:08.492]                           base::stop(msg)
[01:28:08.492]                         }
[01:28:08.492]                       })
[01:28:08.492]                     }
[01:28:08.492]                     base::local({
[01:28:08.492]                       for (pkg in "future") {
[01:28:08.492]                         base::loadNamespace(pkg)
[01:28:08.492]                         base::library(pkg, character.only = TRUE)
[01:28:08.492]                       }
[01:28:08.492]                     })
[01:28:08.492]                   }
[01:28:08.492]                   options(future.plan = NULL)
[01:28:08.492]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.492]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.492]                 }
[01:28:08.492]                 ...future.workdir <- getwd()
[01:28:08.492]             }
[01:28:08.492]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.492]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.492]         }
[01:28:08.492]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.492]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.492]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.492]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.492]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.492]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.492]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.492]             base::names(...future.oldOptions))
[01:28:08.492]     }
[01:28:08.492]     if (FALSE) {
[01:28:08.492]     }
[01:28:08.492]     else {
[01:28:08.492]         if (TRUE) {
[01:28:08.492]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.492]                 open = "w")
[01:28:08.492]         }
[01:28:08.492]         else {
[01:28:08.492]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.492]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.492]         }
[01:28:08.492]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.492]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.492]             base::sink(type = "output", split = FALSE)
[01:28:08.492]             base::close(...future.stdout)
[01:28:08.492]         }, add = TRUE)
[01:28:08.492]     }
[01:28:08.492]     ...future.frame <- base::sys.nframe()
[01:28:08.492]     ...future.conditions <- base::list()
[01:28:08.492]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.492]     if (FALSE) {
[01:28:08.492]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.492]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.492]     }
[01:28:08.492]     ...future.result <- base::tryCatch({
[01:28:08.492]         base::withCallingHandlers({
[01:28:08.492]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.492]                 1))
[01:28:08.492]             future::FutureResult(value = ...future.value$value, 
[01:28:08.492]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.492]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.492]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.492]                     ...future.globalenv.names))
[01:28:08.492]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.492]         }, condition = base::local({
[01:28:08.492]             c <- base::c
[01:28:08.492]             inherits <- base::inherits
[01:28:08.492]             invokeRestart <- base::invokeRestart
[01:28:08.492]             length <- base::length
[01:28:08.492]             list <- base::list
[01:28:08.492]             seq.int <- base::seq.int
[01:28:08.492]             signalCondition <- base::signalCondition
[01:28:08.492]             sys.calls <- base::sys.calls
[01:28:08.492]             `[[` <- base::`[[`
[01:28:08.492]             `+` <- base::`+`
[01:28:08.492]             `<<-` <- base::`<<-`
[01:28:08.492]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.492]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.492]                   3L)]
[01:28:08.492]             }
[01:28:08.492]             function(cond) {
[01:28:08.492]                 is_error <- inherits(cond, "error")
[01:28:08.492]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.492]                   NULL)
[01:28:08.492]                 if (is_error) {
[01:28:08.492]                   sessionInformation <- function() {
[01:28:08.492]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.492]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.492]                       search = base::search(), system = base::Sys.info())
[01:28:08.492]                   }
[01:28:08.492]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.492]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.492]                     cond$call), session = sessionInformation(), 
[01:28:08.492]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.492]                   signalCondition(cond)
[01:28:08.492]                 }
[01:28:08.492]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.492]                 "immediateCondition"))) {
[01:28:08.492]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.492]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.492]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.492]                   if (TRUE && !signal) {
[01:28:08.492]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.492]                     {
[01:28:08.492]                       inherits <- base::inherits
[01:28:08.492]                       invokeRestart <- base::invokeRestart
[01:28:08.492]                       is.null <- base::is.null
[01:28:08.492]                       muffled <- FALSE
[01:28:08.492]                       if (inherits(cond, "message")) {
[01:28:08.492]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.492]                         if (muffled) 
[01:28:08.492]                           invokeRestart("muffleMessage")
[01:28:08.492]                       }
[01:28:08.492]                       else if (inherits(cond, "warning")) {
[01:28:08.492]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.492]                         if (muffled) 
[01:28:08.492]                           invokeRestart("muffleWarning")
[01:28:08.492]                       }
[01:28:08.492]                       else if (inherits(cond, "condition")) {
[01:28:08.492]                         if (!is.null(pattern)) {
[01:28:08.492]                           computeRestarts <- base::computeRestarts
[01:28:08.492]                           grepl <- base::grepl
[01:28:08.492]                           restarts <- computeRestarts(cond)
[01:28:08.492]                           for (restart in restarts) {
[01:28:08.492]                             name <- restart$name
[01:28:08.492]                             if (is.null(name)) 
[01:28:08.492]                               next
[01:28:08.492]                             if (!grepl(pattern, name)) 
[01:28:08.492]                               next
[01:28:08.492]                             invokeRestart(restart)
[01:28:08.492]                             muffled <- TRUE
[01:28:08.492]                             break
[01:28:08.492]                           }
[01:28:08.492]                         }
[01:28:08.492]                       }
[01:28:08.492]                       invisible(muffled)
[01:28:08.492]                     }
[01:28:08.492]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.492]                   }
[01:28:08.492]                 }
[01:28:08.492]                 else {
[01:28:08.492]                   if (TRUE) {
[01:28:08.492]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.492]                     {
[01:28:08.492]                       inherits <- base::inherits
[01:28:08.492]                       invokeRestart <- base::invokeRestart
[01:28:08.492]                       is.null <- base::is.null
[01:28:08.492]                       muffled <- FALSE
[01:28:08.492]                       if (inherits(cond, "message")) {
[01:28:08.492]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.492]                         if (muffled) 
[01:28:08.492]                           invokeRestart("muffleMessage")
[01:28:08.492]                       }
[01:28:08.492]                       else if (inherits(cond, "warning")) {
[01:28:08.492]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.492]                         if (muffled) 
[01:28:08.492]                           invokeRestart("muffleWarning")
[01:28:08.492]                       }
[01:28:08.492]                       else if (inherits(cond, "condition")) {
[01:28:08.492]                         if (!is.null(pattern)) {
[01:28:08.492]                           computeRestarts <- base::computeRestarts
[01:28:08.492]                           grepl <- base::grepl
[01:28:08.492]                           restarts <- computeRestarts(cond)
[01:28:08.492]                           for (restart in restarts) {
[01:28:08.492]                             name <- restart$name
[01:28:08.492]                             if (is.null(name)) 
[01:28:08.492]                               next
[01:28:08.492]                             if (!grepl(pattern, name)) 
[01:28:08.492]                               next
[01:28:08.492]                             invokeRestart(restart)
[01:28:08.492]                             muffled <- TRUE
[01:28:08.492]                             break
[01:28:08.492]                           }
[01:28:08.492]                         }
[01:28:08.492]                       }
[01:28:08.492]                       invisible(muffled)
[01:28:08.492]                     }
[01:28:08.492]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.492]                   }
[01:28:08.492]                 }
[01:28:08.492]             }
[01:28:08.492]         }))
[01:28:08.492]     }, error = function(ex) {
[01:28:08.492]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.492]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.492]                 ...future.rng), started = ...future.startTime, 
[01:28:08.492]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.492]             version = "1.8"), class = "FutureResult")
[01:28:08.492]     }, finally = {
[01:28:08.492]         if (!identical(...future.workdir, getwd())) 
[01:28:08.492]             setwd(...future.workdir)
[01:28:08.492]         {
[01:28:08.492]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.492]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.492]             }
[01:28:08.492]             base::options(...future.oldOptions)
[01:28:08.492]             if (.Platform$OS.type == "windows") {
[01:28:08.492]                 old_names <- names(...future.oldEnvVars)
[01:28:08.492]                 envs <- base::Sys.getenv()
[01:28:08.492]                 names <- names(envs)
[01:28:08.492]                 common <- intersect(names, old_names)
[01:28:08.492]                 added <- setdiff(names, old_names)
[01:28:08.492]                 removed <- setdiff(old_names, names)
[01:28:08.492]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.492]                   envs[common]]
[01:28:08.492]                 NAMES <- toupper(changed)
[01:28:08.492]                 args <- list()
[01:28:08.492]                 for (kk in seq_along(NAMES)) {
[01:28:08.492]                   name <- changed[[kk]]
[01:28:08.492]                   NAME <- NAMES[[kk]]
[01:28:08.492]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.492]                     next
[01:28:08.492]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.492]                 }
[01:28:08.492]                 NAMES <- toupper(added)
[01:28:08.492]                 for (kk in seq_along(NAMES)) {
[01:28:08.492]                   name <- added[[kk]]
[01:28:08.492]                   NAME <- NAMES[[kk]]
[01:28:08.492]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.492]                     next
[01:28:08.492]                   args[[name]] <- ""
[01:28:08.492]                 }
[01:28:08.492]                 NAMES <- toupper(removed)
[01:28:08.492]                 for (kk in seq_along(NAMES)) {
[01:28:08.492]                   name <- removed[[kk]]
[01:28:08.492]                   NAME <- NAMES[[kk]]
[01:28:08.492]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.492]                     next
[01:28:08.492]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.492]                 }
[01:28:08.492]                 if (length(args) > 0) 
[01:28:08.492]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.492]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.492]             }
[01:28:08.492]             else {
[01:28:08.492]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.492]             }
[01:28:08.492]             {
[01:28:08.492]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.492]                   0L) {
[01:28:08.492]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.492]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.492]                   base::options(opts)
[01:28:08.492]                 }
[01:28:08.492]                 {
[01:28:08.492]                   {
[01:28:08.492]                     NULL
[01:28:08.492]                     RNGkind("Mersenne-Twister")
[01:28:08.492]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.492]                       inherits = FALSE)
[01:28:08.492]                   }
[01:28:08.492]                   options(future.plan = NULL)
[01:28:08.492]                   if (is.na(NA_character_)) 
[01:28:08.492]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.492]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.492]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.492]                   {
[01:28:08.492]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.492]                     if (!future$lazy) 
[01:28:08.492]                       future <- run(future)
[01:28:08.492]                     invisible(future)
[01:28:08.492]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.492]                 }
[01:28:08.492]             }
[01:28:08.492]         }
[01:28:08.492]     })
[01:28:08.492]     if (TRUE) {
[01:28:08.492]         base::sink(type = "output", split = FALSE)
[01:28:08.492]         if (TRUE) {
[01:28:08.492]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.492]         }
[01:28:08.492]         else {
[01:28:08.492]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.492]         }
[01:28:08.492]         base::close(...future.stdout)
[01:28:08.492]         ...future.stdout <- NULL
[01:28:08.492]     }
[01:28:08.492]     ...future.result$conditions <- ...future.conditions
[01:28:08.492]     ...future.result$finished <- base::Sys.time()
[01:28:08.492]     ...future.result
[01:28:08.492] }
[01:28:08.496] assign_globals() ...
[01:28:08.496] List of 1
[01:28:08.496]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d8a49688> 
[01:28:08.496]  - attr(*, "where")=List of 1
[01:28:08.496]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.496]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.496]  - attr(*, "resolved")= logi TRUE
[01:28:08.496]  - attr(*, "total_size")= num 1638312
[01:28:08.496]  - attr(*, "already-done")= logi TRUE
[01:28:08.499] - copied 'a' to environment
[01:28:08.499] assign_globals() ... done
[01:28:08.500] plan(): Setting new future strategy stack:
[01:28:08.500] List of future strategies:
[01:28:08.500] 1. sequential:
[01:28:08.500]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.500]    - tweaked: FALSE
[01:28:08.500]    - call: NULL
[01:28:08.501] plan(): nbrOfWorkers() = 1
[01:28:08.502] plan(): Setting new future strategy stack:
[01:28:08.502] List of future strategies:
[01:28:08.502] 1. sequential:
[01:28:08.502]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.502]    - tweaked: FALSE
[01:28:08.502]    - call: plan(strategy)
[01:28:08.503] plan(): nbrOfWorkers() = 1
[01:28:08.503] SequentialFuture started (and completed)
[01:28:08.503] - Launch lazy future ... done
[01:28:08.503] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.505] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.505] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.506] 
[01:28:08.506] Searching for globals ... DONE
[01:28:08.506] - globals: [0] <none>
[01:28:08.506] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.507] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.507] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.508] - globals found: [3] '+', 'value', 'a'
[01:28:08.508] Searching for globals ... DONE
[01:28:08.509] Resolving globals: TRUE
[01:28:08.509] Resolving any globals that are futures ...
[01:28:08.509] - globals: [3] '+', 'value', 'a'
[01:28:08.509] Resolving any globals that are futures ... DONE
[01:28:08.510] Resolving futures part of globals (recursively) ...
[01:28:08.510] resolve() on list ...
[01:28:08.510]  recursive: 99
[01:28:08.510]  length: 1
[01:28:08.511]  elements: 'a'
[01:28:08.511] run() for 'Future' ...
[01:28:08.511] - state: 'created'
[01:28:08.511] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.512] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.512] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.512]   - Field: 'label'
[01:28:08.512]   - Field: 'local'
[01:28:08.512]   - Field: 'owner'
[01:28:08.512]   - Field: 'envir'
[01:28:08.513]   - Field: 'packages'
[01:28:08.513]   - Field: 'gc'
[01:28:08.513]   - Field: 'conditions'
[01:28:08.513]   - Field: 'expr'
[01:28:08.513]   - Field: 'uuid'
[01:28:08.514]   - Field: 'seed'
[01:28:08.514]   - Field: 'version'
[01:28:08.514]   - Field: 'result'
[01:28:08.514]   - Field: 'asynchronous'
[01:28:08.514]   - Field: 'calls'
[01:28:08.514]   - Field: 'globals'
[01:28:08.515]   - Field: 'stdout'
[01:28:08.515]   - Field: 'earlySignal'
[01:28:08.515]   - Field: 'lazy'
[01:28:08.515]   - Field: 'state'
[01:28:08.515] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.515] - Launch lazy future ...
[01:28:08.516] Packages needed by the future expression (n = 0): <none>
[01:28:08.516] Packages needed by future strategies (n = 0): <none>
[01:28:08.516] {
[01:28:08.516]     {
[01:28:08.516]         {
[01:28:08.516]             ...future.startTime <- base::Sys.time()
[01:28:08.516]             {
[01:28:08.516]                 {
[01:28:08.516]                   {
[01:28:08.516]                     base::local({
[01:28:08.516]                       has_future <- base::requireNamespace("future", 
[01:28:08.516]                         quietly = TRUE)
[01:28:08.516]                       if (has_future) {
[01:28:08.516]                         ns <- base::getNamespace("future")
[01:28:08.516]                         version <- ns[[".package"]][["version"]]
[01:28:08.516]                         if (is.null(version)) 
[01:28:08.516]                           version <- utils::packageVersion("future")
[01:28:08.516]                       }
[01:28:08.516]                       else {
[01:28:08.516]                         version <- NULL
[01:28:08.516]                       }
[01:28:08.516]                       if (!has_future || version < "1.8.0") {
[01:28:08.516]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.516]                           "", base::R.version$version.string), 
[01:28:08.516]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.516]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.516]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.516]                             "release", "version")], collapse = " "), 
[01:28:08.516]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.516]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.516]                           info)
[01:28:08.516]                         info <- base::paste(info, collapse = "; ")
[01:28:08.516]                         if (!has_future) {
[01:28:08.516]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.516]                             info)
[01:28:08.516]                         }
[01:28:08.516]                         else {
[01:28:08.516]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.516]                             info, version)
[01:28:08.516]                         }
[01:28:08.516]                         base::stop(msg)
[01:28:08.516]                       }
[01:28:08.516]                     })
[01:28:08.516]                   }
[01:28:08.516]                   options(future.plan = NULL)
[01:28:08.516]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.516]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.516]                 }
[01:28:08.516]                 ...future.workdir <- getwd()
[01:28:08.516]             }
[01:28:08.516]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.516]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.516]         }
[01:28:08.516]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.516]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.516]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.516]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.516]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.516]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.516]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.516]             base::names(...future.oldOptions))
[01:28:08.516]     }
[01:28:08.516]     if (FALSE) {
[01:28:08.516]     }
[01:28:08.516]     else {
[01:28:08.516]         if (TRUE) {
[01:28:08.516]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.516]                 open = "w")
[01:28:08.516]         }
[01:28:08.516]         else {
[01:28:08.516]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.516]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.516]         }
[01:28:08.516]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.516]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.516]             base::sink(type = "output", split = FALSE)
[01:28:08.516]             base::close(...future.stdout)
[01:28:08.516]         }, add = TRUE)
[01:28:08.516]     }
[01:28:08.516]     ...future.frame <- base::sys.nframe()
[01:28:08.516]     ...future.conditions <- base::list()
[01:28:08.516]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.516]     if (FALSE) {
[01:28:08.516]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.516]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.516]     }
[01:28:08.516]     ...future.result <- base::tryCatch({
[01:28:08.516]         base::withCallingHandlers({
[01:28:08.516]             ...future.value <- base::withVisible(base::local(1))
[01:28:08.516]             future::FutureResult(value = ...future.value$value, 
[01:28:08.516]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.516]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.516]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.516]                     ...future.globalenv.names))
[01:28:08.516]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.516]         }, condition = base::local({
[01:28:08.516]             c <- base::c
[01:28:08.516]             inherits <- base::inherits
[01:28:08.516]             invokeRestart <- base::invokeRestart
[01:28:08.516]             length <- base::length
[01:28:08.516]             list <- base::list
[01:28:08.516]             seq.int <- base::seq.int
[01:28:08.516]             signalCondition <- base::signalCondition
[01:28:08.516]             sys.calls <- base::sys.calls
[01:28:08.516]             `[[` <- base::`[[`
[01:28:08.516]             `+` <- base::`+`
[01:28:08.516]             `<<-` <- base::`<<-`
[01:28:08.516]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.516]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.516]                   3L)]
[01:28:08.516]             }
[01:28:08.516]             function(cond) {
[01:28:08.516]                 is_error <- inherits(cond, "error")
[01:28:08.516]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.516]                   NULL)
[01:28:08.516]                 if (is_error) {
[01:28:08.516]                   sessionInformation <- function() {
[01:28:08.516]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.516]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.516]                       search = base::search(), system = base::Sys.info())
[01:28:08.516]                   }
[01:28:08.516]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.516]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.516]                     cond$call), session = sessionInformation(), 
[01:28:08.516]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.516]                   signalCondition(cond)
[01:28:08.516]                 }
[01:28:08.516]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.516]                 "immediateCondition"))) {
[01:28:08.516]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.516]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.516]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.516]                   if (TRUE && !signal) {
[01:28:08.516]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.516]                     {
[01:28:08.516]                       inherits <- base::inherits
[01:28:08.516]                       invokeRestart <- base::invokeRestart
[01:28:08.516]                       is.null <- base::is.null
[01:28:08.516]                       muffled <- FALSE
[01:28:08.516]                       if (inherits(cond, "message")) {
[01:28:08.516]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.516]                         if (muffled) 
[01:28:08.516]                           invokeRestart("muffleMessage")
[01:28:08.516]                       }
[01:28:08.516]                       else if (inherits(cond, "warning")) {
[01:28:08.516]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.516]                         if (muffled) 
[01:28:08.516]                           invokeRestart("muffleWarning")
[01:28:08.516]                       }
[01:28:08.516]                       else if (inherits(cond, "condition")) {
[01:28:08.516]                         if (!is.null(pattern)) {
[01:28:08.516]                           computeRestarts <- base::computeRestarts
[01:28:08.516]                           grepl <- base::grepl
[01:28:08.516]                           restarts <- computeRestarts(cond)
[01:28:08.516]                           for (restart in restarts) {
[01:28:08.516]                             name <- restart$name
[01:28:08.516]                             if (is.null(name)) 
[01:28:08.516]                               next
[01:28:08.516]                             if (!grepl(pattern, name)) 
[01:28:08.516]                               next
[01:28:08.516]                             invokeRestart(restart)
[01:28:08.516]                             muffled <- TRUE
[01:28:08.516]                             break
[01:28:08.516]                           }
[01:28:08.516]                         }
[01:28:08.516]                       }
[01:28:08.516]                       invisible(muffled)
[01:28:08.516]                     }
[01:28:08.516]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.516]                   }
[01:28:08.516]                 }
[01:28:08.516]                 else {
[01:28:08.516]                   if (TRUE) {
[01:28:08.516]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.516]                     {
[01:28:08.516]                       inherits <- base::inherits
[01:28:08.516]                       invokeRestart <- base::invokeRestart
[01:28:08.516]                       is.null <- base::is.null
[01:28:08.516]                       muffled <- FALSE
[01:28:08.516]                       if (inherits(cond, "message")) {
[01:28:08.516]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.516]                         if (muffled) 
[01:28:08.516]                           invokeRestart("muffleMessage")
[01:28:08.516]                       }
[01:28:08.516]                       else if (inherits(cond, "warning")) {
[01:28:08.516]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.516]                         if (muffled) 
[01:28:08.516]                           invokeRestart("muffleWarning")
[01:28:08.516]                       }
[01:28:08.516]                       else if (inherits(cond, "condition")) {
[01:28:08.516]                         if (!is.null(pattern)) {
[01:28:08.516]                           computeRestarts <- base::computeRestarts
[01:28:08.516]                           grepl <- base::grepl
[01:28:08.516]                           restarts <- computeRestarts(cond)
[01:28:08.516]                           for (restart in restarts) {
[01:28:08.516]                             name <- restart$name
[01:28:08.516]                             if (is.null(name)) 
[01:28:08.516]                               next
[01:28:08.516]                             if (!grepl(pattern, name)) 
[01:28:08.516]                               next
[01:28:08.516]                             invokeRestart(restart)
[01:28:08.516]                             muffled <- TRUE
[01:28:08.516]                             break
[01:28:08.516]                           }
[01:28:08.516]                         }
[01:28:08.516]                       }
[01:28:08.516]                       invisible(muffled)
[01:28:08.516]                     }
[01:28:08.516]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.516]                   }
[01:28:08.516]                 }
[01:28:08.516]             }
[01:28:08.516]         }))
[01:28:08.516]     }, error = function(ex) {
[01:28:08.516]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.516]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.516]                 ...future.rng), started = ...future.startTime, 
[01:28:08.516]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.516]             version = "1.8"), class = "FutureResult")
[01:28:08.516]     }, finally = {
[01:28:08.516]         if (!identical(...future.workdir, getwd())) 
[01:28:08.516]             setwd(...future.workdir)
[01:28:08.516]         {
[01:28:08.516]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.516]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.516]             }
[01:28:08.516]             base::options(...future.oldOptions)
[01:28:08.516]             if (.Platform$OS.type == "windows") {
[01:28:08.516]                 old_names <- names(...future.oldEnvVars)
[01:28:08.516]                 envs <- base::Sys.getenv()
[01:28:08.516]                 names <- names(envs)
[01:28:08.516]                 common <- intersect(names, old_names)
[01:28:08.516]                 added <- setdiff(names, old_names)
[01:28:08.516]                 removed <- setdiff(old_names, names)
[01:28:08.516]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.516]                   envs[common]]
[01:28:08.516]                 NAMES <- toupper(changed)
[01:28:08.516]                 args <- list()
[01:28:08.516]                 for (kk in seq_along(NAMES)) {
[01:28:08.516]                   name <- changed[[kk]]
[01:28:08.516]                   NAME <- NAMES[[kk]]
[01:28:08.516]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.516]                     next
[01:28:08.516]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.516]                 }
[01:28:08.516]                 NAMES <- toupper(added)
[01:28:08.516]                 for (kk in seq_along(NAMES)) {
[01:28:08.516]                   name <- added[[kk]]
[01:28:08.516]                   NAME <- NAMES[[kk]]
[01:28:08.516]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.516]                     next
[01:28:08.516]                   args[[name]] <- ""
[01:28:08.516]                 }
[01:28:08.516]                 NAMES <- toupper(removed)
[01:28:08.516]                 for (kk in seq_along(NAMES)) {
[01:28:08.516]                   name <- removed[[kk]]
[01:28:08.516]                   NAME <- NAMES[[kk]]
[01:28:08.516]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.516]                     next
[01:28:08.516]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.516]                 }
[01:28:08.516]                 if (length(args) > 0) 
[01:28:08.516]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.516]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.516]             }
[01:28:08.516]             else {
[01:28:08.516]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.516]             }
[01:28:08.516]             {
[01:28:08.516]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.516]                   0L) {
[01:28:08.516]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.516]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.516]                   base::options(opts)
[01:28:08.516]                 }
[01:28:08.516]                 {
[01:28:08.516]                   {
[01:28:08.516]                     NULL
[01:28:08.516]                     RNGkind("Mersenne-Twister")
[01:28:08.516]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.516]                       inherits = FALSE)
[01:28:08.516]                   }
[01:28:08.516]                   options(future.plan = NULL)
[01:28:08.516]                   if (is.na(NA_character_)) 
[01:28:08.516]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.516]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.516]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.516]                   {
[01:28:08.516]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.516]                     if (!future$lazy) 
[01:28:08.516]                       future <- run(future)
[01:28:08.516]                     invisible(future)
[01:28:08.516]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.516]                 }
[01:28:08.516]             }
[01:28:08.516]         }
[01:28:08.516]     })
[01:28:08.516]     if (TRUE) {
[01:28:08.516]         base::sink(type = "output", split = FALSE)
[01:28:08.516]         if (TRUE) {
[01:28:08.516]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.516]         }
[01:28:08.516]         else {
[01:28:08.516]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.516]         }
[01:28:08.516]         base::close(...future.stdout)
[01:28:08.516]         ...future.stdout <- NULL
[01:28:08.516]     }
[01:28:08.516]     ...future.result$conditions <- ...future.conditions
[01:28:08.516]     ...future.result$finished <- base::Sys.time()
[01:28:08.516]     ...future.result
[01:28:08.516] }
[01:28:08.520] plan(): Setting new future strategy stack:
[01:28:08.520] List of future strategies:
[01:28:08.520] 1. sequential:
[01:28:08.520]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.520]    - tweaked: FALSE
[01:28:08.520]    - call: NULL
[01:28:08.521] plan(): nbrOfWorkers() = 1
[01:28:08.522] plan(): Setting new future strategy stack:
[01:28:08.522] List of future strategies:
[01:28:08.522] 1. sequential:
[01:28:08.522]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.522]    - tweaked: FALSE
[01:28:08.522]    - call: plan(strategy)
[01:28:08.523] plan(): nbrOfWorkers() = 1
[01:28:08.523] SequentialFuture started (and completed)
[01:28:08.523] - Launch lazy future ... done
[01:28:08.523] run() for 'SequentialFuture' ... done
[01:28:08.524] resolved() for 'SequentialFuture' ...
[01:28:08.524] - state: 'finished'
[01:28:08.524] - run: TRUE
[01:28:08.524] - result: 'FutureResult'
[01:28:08.524] resolved() for 'SequentialFuture' ... done
[01:28:08.524] Future #1
[01:28:08.525] resolved() for 'SequentialFuture' ...
[01:28:08.525] - state: 'finished'
[01:28:08.525] - run: TRUE
[01:28:08.525] - result: 'FutureResult'
[01:28:08.526] resolved() for 'SequentialFuture' ... done
[01:28:08.526] A SequentialFuture was resolved
[01:28:08.526]  length: 0 (resolved future 1)
[01:28:08.526] resolve() on list ... DONE
[01:28:08.526] - globals: [1] 'a'
[01:28:08.526] Resolving futures part of globals (recursively) ... DONE
[01:28:08.529] The total size of the 1 globals is 1.56 MiB (1638312 bytes)
[01:28:08.529] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.56 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.56 MiB of class 'environment')
[01:28:08.529] - globals: [1] 'a'
[01:28:08.529] - packages: [1] 'future'
[01:28:08.530] getGlobalsAndPackages() ... DONE
[01:28:08.530] run() for 'Future' ...
[01:28:08.530] - state: 'created'
[01:28:08.530] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.531] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.531] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.531]   - Field: 'label'
[01:28:08.531]   - Field: 'local'
[01:28:08.531]   - Field: 'owner'
[01:28:08.532]   - Field: 'envir'
[01:28:08.532]   - Field: 'packages'
[01:28:08.532]   - Field: 'gc'
[01:28:08.532]   - Field: 'conditions'
[01:28:08.532]   - Field: 'expr'
[01:28:08.533]   - Field: 'uuid'
[01:28:08.533]   - Field: 'seed'
[01:28:08.533]   - Field: 'version'
[01:28:08.533]   - Field: 'result'
[01:28:08.533]   - Field: 'asynchronous'
[01:28:08.533]   - Field: 'calls'
[01:28:08.534]   - Field: 'globals'
[01:28:08.534]   - Field: 'stdout'
[01:28:08.534]   - Field: 'earlySignal'
[01:28:08.534]   - Field: 'lazy'
[01:28:08.534]   - Field: 'state'
[01:28:08.534] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.535] - Launch lazy future ...
[01:28:08.535] Packages needed by the future expression (n = 1): 'future'
[01:28:08.535] Packages needed by future strategies (n = 0): <none>
[01:28:08.536] {
[01:28:08.536]     {
[01:28:08.536]         {
[01:28:08.536]             ...future.startTime <- base::Sys.time()
[01:28:08.536]             {
[01:28:08.536]                 {
[01:28:08.536]                   {
[01:28:08.536]                     {
[01:28:08.536]                       base::local({
[01:28:08.536]                         has_future <- base::requireNamespace("future", 
[01:28:08.536]                           quietly = TRUE)
[01:28:08.536]                         if (has_future) {
[01:28:08.536]                           ns <- base::getNamespace("future")
[01:28:08.536]                           version <- ns[[".package"]][["version"]]
[01:28:08.536]                           if (is.null(version)) 
[01:28:08.536]                             version <- utils::packageVersion("future")
[01:28:08.536]                         }
[01:28:08.536]                         else {
[01:28:08.536]                           version <- NULL
[01:28:08.536]                         }
[01:28:08.536]                         if (!has_future || version < "1.8.0") {
[01:28:08.536]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.536]                             "", base::R.version$version.string), 
[01:28:08.536]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:08.536]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.536]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.536]                               "release", "version")], collapse = " "), 
[01:28:08.536]                             hostname = base::Sys.info()[["nodename"]])
[01:28:08.536]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.536]                             info)
[01:28:08.536]                           info <- base::paste(info, collapse = "; ")
[01:28:08.536]                           if (!has_future) {
[01:28:08.536]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.536]                               info)
[01:28:08.536]                           }
[01:28:08.536]                           else {
[01:28:08.536]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.536]                               info, version)
[01:28:08.536]                           }
[01:28:08.536]                           base::stop(msg)
[01:28:08.536]                         }
[01:28:08.536]                       })
[01:28:08.536]                     }
[01:28:08.536]                     base::local({
[01:28:08.536]                       for (pkg in "future") {
[01:28:08.536]                         base::loadNamespace(pkg)
[01:28:08.536]                         base::library(pkg, character.only = TRUE)
[01:28:08.536]                       }
[01:28:08.536]                     })
[01:28:08.536]                   }
[01:28:08.536]                   options(future.plan = NULL)
[01:28:08.536]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.536]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.536]                 }
[01:28:08.536]                 ...future.workdir <- getwd()
[01:28:08.536]             }
[01:28:08.536]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.536]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.536]         }
[01:28:08.536]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.536]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.536]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.536]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.536]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.536]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.536]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.536]             base::names(...future.oldOptions))
[01:28:08.536]     }
[01:28:08.536]     if (FALSE) {
[01:28:08.536]     }
[01:28:08.536]     else {
[01:28:08.536]         if (TRUE) {
[01:28:08.536]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.536]                 open = "w")
[01:28:08.536]         }
[01:28:08.536]         else {
[01:28:08.536]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.536]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.536]         }
[01:28:08.536]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.536]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.536]             base::sink(type = "output", split = FALSE)
[01:28:08.536]             base::close(...future.stdout)
[01:28:08.536]         }, add = TRUE)
[01:28:08.536]     }
[01:28:08.536]     ...future.frame <- base::sys.nframe()
[01:28:08.536]     ...future.conditions <- base::list()
[01:28:08.536]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.536]     if (FALSE) {
[01:28:08.536]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.536]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.536]     }
[01:28:08.536]     ...future.result <- base::tryCatch({
[01:28:08.536]         base::withCallingHandlers({
[01:28:08.536]             ...future.value <- base::withVisible(base::local(value(a) + 
[01:28:08.536]                 1))
[01:28:08.536]             future::FutureResult(value = ...future.value$value, 
[01:28:08.536]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.536]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.536]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.536]                     ...future.globalenv.names))
[01:28:08.536]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.536]         }, condition = base::local({
[01:28:08.536]             c <- base::c
[01:28:08.536]             inherits <- base::inherits
[01:28:08.536]             invokeRestart <- base::invokeRestart
[01:28:08.536]             length <- base::length
[01:28:08.536]             list <- base::list
[01:28:08.536]             seq.int <- base::seq.int
[01:28:08.536]             signalCondition <- base::signalCondition
[01:28:08.536]             sys.calls <- base::sys.calls
[01:28:08.536]             `[[` <- base::`[[`
[01:28:08.536]             `+` <- base::`+`
[01:28:08.536]             `<<-` <- base::`<<-`
[01:28:08.536]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.536]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.536]                   3L)]
[01:28:08.536]             }
[01:28:08.536]             function(cond) {
[01:28:08.536]                 is_error <- inherits(cond, "error")
[01:28:08.536]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.536]                   NULL)
[01:28:08.536]                 if (is_error) {
[01:28:08.536]                   sessionInformation <- function() {
[01:28:08.536]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.536]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.536]                       search = base::search(), system = base::Sys.info())
[01:28:08.536]                   }
[01:28:08.536]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.536]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.536]                     cond$call), session = sessionInformation(), 
[01:28:08.536]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.536]                   signalCondition(cond)
[01:28:08.536]                 }
[01:28:08.536]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.536]                 "immediateCondition"))) {
[01:28:08.536]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.536]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.536]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.536]                   if (TRUE && !signal) {
[01:28:08.536]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.536]                     {
[01:28:08.536]                       inherits <- base::inherits
[01:28:08.536]                       invokeRestart <- base::invokeRestart
[01:28:08.536]                       is.null <- base::is.null
[01:28:08.536]                       muffled <- FALSE
[01:28:08.536]                       if (inherits(cond, "message")) {
[01:28:08.536]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.536]                         if (muffled) 
[01:28:08.536]                           invokeRestart("muffleMessage")
[01:28:08.536]                       }
[01:28:08.536]                       else if (inherits(cond, "warning")) {
[01:28:08.536]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.536]                         if (muffled) 
[01:28:08.536]                           invokeRestart("muffleWarning")
[01:28:08.536]                       }
[01:28:08.536]                       else if (inherits(cond, "condition")) {
[01:28:08.536]                         if (!is.null(pattern)) {
[01:28:08.536]                           computeRestarts <- base::computeRestarts
[01:28:08.536]                           grepl <- base::grepl
[01:28:08.536]                           restarts <- computeRestarts(cond)
[01:28:08.536]                           for (restart in restarts) {
[01:28:08.536]                             name <- restart$name
[01:28:08.536]                             if (is.null(name)) 
[01:28:08.536]                               next
[01:28:08.536]                             if (!grepl(pattern, name)) 
[01:28:08.536]                               next
[01:28:08.536]                             invokeRestart(restart)
[01:28:08.536]                             muffled <- TRUE
[01:28:08.536]                             break
[01:28:08.536]                           }
[01:28:08.536]                         }
[01:28:08.536]                       }
[01:28:08.536]                       invisible(muffled)
[01:28:08.536]                     }
[01:28:08.536]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.536]                   }
[01:28:08.536]                 }
[01:28:08.536]                 else {
[01:28:08.536]                   if (TRUE) {
[01:28:08.536]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.536]                     {
[01:28:08.536]                       inherits <- base::inherits
[01:28:08.536]                       invokeRestart <- base::invokeRestart
[01:28:08.536]                       is.null <- base::is.null
[01:28:08.536]                       muffled <- FALSE
[01:28:08.536]                       if (inherits(cond, "message")) {
[01:28:08.536]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.536]                         if (muffled) 
[01:28:08.536]                           invokeRestart("muffleMessage")
[01:28:08.536]                       }
[01:28:08.536]                       else if (inherits(cond, "warning")) {
[01:28:08.536]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.536]                         if (muffled) 
[01:28:08.536]                           invokeRestart("muffleWarning")
[01:28:08.536]                       }
[01:28:08.536]                       else if (inherits(cond, "condition")) {
[01:28:08.536]                         if (!is.null(pattern)) {
[01:28:08.536]                           computeRestarts <- base::computeRestarts
[01:28:08.536]                           grepl <- base::grepl
[01:28:08.536]                           restarts <- computeRestarts(cond)
[01:28:08.536]                           for (restart in restarts) {
[01:28:08.536]                             name <- restart$name
[01:28:08.536]                             if (is.null(name)) 
[01:28:08.536]                               next
[01:28:08.536]                             if (!grepl(pattern, name)) 
[01:28:08.536]                               next
[01:28:08.536]                             invokeRestart(restart)
[01:28:08.536]                             muffled <- TRUE
[01:28:08.536]                             break
[01:28:08.536]                           }
[01:28:08.536]                         }
[01:28:08.536]                       }
[01:28:08.536]                       invisible(muffled)
[01:28:08.536]                     }
[01:28:08.536]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.536]                   }
[01:28:08.536]                 }
[01:28:08.536]             }
[01:28:08.536]         }))
[01:28:08.536]     }, error = function(ex) {
[01:28:08.536]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.536]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.536]                 ...future.rng), started = ...future.startTime, 
[01:28:08.536]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.536]             version = "1.8"), class = "FutureResult")
[01:28:08.536]     }, finally = {
[01:28:08.536]         if (!identical(...future.workdir, getwd())) 
[01:28:08.536]             setwd(...future.workdir)
[01:28:08.536]         {
[01:28:08.536]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.536]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.536]             }
[01:28:08.536]             base::options(...future.oldOptions)
[01:28:08.536]             if (.Platform$OS.type == "windows") {
[01:28:08.536]                 old_names <- names(...future.oldEnvVars)
[01:28:08.536]                 envs <- base::Sys.getenv()
[01:28:08.536]                 names <- names(envs)
[01:28:08.536]                 common <- intersect(names, old_names)
[01:28:08.536]                 added <- setdiff(names, old_names)
[01:28:08.536]                 removed <- setdiff(old_names, names)
[01:28:08.536]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.536]                   envs[common]]
[01:28:08.536]                 NAMES <- toupper(changed)
[01:28:08.536]                 args <- list()
[01:28:08.536]                 for (kk in seq_along(NAMES)) {
[01:28:08.536]                   name <- changed[[kk]]
[01:28:08.536]                   NAME <- NAMES[[kk]]
[01:28:08.536]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.536]                     next
[01:28:08.536]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.536]                 }
[01:28:08.536]                 NAMES <- toupper(added)
[01:28:08.536]                 for (kk in seq_along(NAMES)) {
[01:28:08.536]                   name <- added[[kk]]
[01:28:08.536]                   NAME <- NAMES[[kk]]
[01:28:08.536]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.536]                     next
[01:28:08.536]                   args[[name]] <- ""
[01:28:08.536]                 }
[01:28:08.536]                 NAMES <- toupper(removed)
[01:28:08.536]                 for (kk in seq_along(NAMES)) {
[01:28:08.536]                   name <- removed[[kk]]
[01:28:08.536]                   NAME <- NAMES[[kk]]
[01:28:08.536]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.536]                     next
[01:28:08.536]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.536]                 }
[01:28:08.536]                 if (length(args) > 0) 
[01:28:08.536]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.536]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.536]             }
[01:28:08.536]             else {
[01:28:08.536]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.536]             }
[01:28:08.536]             {
[01:28:08.536]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.536]                   0L) {
[01:28:08.536]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.536]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.536]                   base::options(opts)
[01:28:08.536]                 }
[01:28:08.536]                 {
[01:28:08.536]                   {
[01:28:08.536]                     NULL
[01:28:08.536]                     RNGkind("Mersenne-Twister")
[01:28:08.536]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.536]                       inherits = FALSE)
[01:28:08.536]                   }
[01:28:08.536]                   options(future.plan = NULL)
[01:28:08.536]                   if (is.na(NA_character_)) 
[01:28:08.536]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.536]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.536]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.536]                   {
[01:28:08.536]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.536]                     if (!future$lazy) 
[01:28:08.536]                       future <- run(future)
[01:28:08.536]                     invisible(future)
[01:28:08.536]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.536]                 }
[01:28:08.536]             }
[01:28:08.536]         }
[01:28:08.536]     })
[01:28:08.536]     if (TRUE) {
[01:28:08.536]         base::sink(type = "output", split = FALSE)
[01:28:08.536]         if (TRUE) {
[01:28:08.536]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.536]         }
[01:28:08.536]         else {
[01:28:08.536]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.536]         }
[01:28:08.536]         base::close(...future.stdout)
[01:28:08.536]         ...future.stdout <- NULL
[01:28:08.536]     }
[01:28:08.536]     ...future.result$conditions <- ...future.conditions
[01:28:08.536]     ...future.result$finished <- base::Sys.time()
[01:28:08.536]     ...future.result
[01:28:08.536] }
[01:28:08.539] assign_globals() ...
[01:28:08.539] List of 1
[01:28:08.539]  $ a:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000001f1d886a728> 
[01:28:08.539]  - attr(*, "where")=List of 1
[01:28:08.539]   ..$ a:<environment: R_EmptyEnv> 
[01:28:08.539]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.539]  - attr(*, "resolved")= logi TRUE
[01:28:08.539]  - attr(*, "total_size")= num 1638312
[01:28:08.539]  - attr(*, "already-done")= logi TRUE
[01:28:08.543] - copied 'a' to environment
[01:28:08.544] assign_globals() ... done
[01:28:08.544] plan(): Setting new future strategy stack:
[01:28:08.544] List of future strategies:
[01:28:08.544] 1. sequential:
[01:28:08.544]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.544]    - tweaked: FALSE
[01:28:08.544]    - call: NULL
[01:28:08.545] plan(): nbrOfWorkers() = 1
[01:28:08.546] plan(): Setting new future strategy stack:
[01:28:08.546] List of future strategies:
[01:28:08.546] 1. sequential:
[01:28:08.546]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.546]    - tweaked: FALSE
[01:28:08.546]    - call: plan(strategy)
[01:28:08.547] plan(): nbrOfWorkers() = 1
[01:28:08.547] SequentialFuture started (and completed)
[01:28:08.547] - Launch lazy future ... done
[01:28:08.548] run() for 'SequentialFuture' ... done
value(b) = 2
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.548] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.549] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.549] - globals found: [2] '{', 'pkg'
[01:28:08.550] Searching for globals ... DONE
[01:28:08.550] Resolving globals: TRUE
[01:28:08.550] Resolving any globals that are futures ...
[01:28:08.550] - globals: [2] '{', 'pkg'
[01:28:08.550] Resolving any globals that are futures ... DONE
[01:28:08.551] Resolving futures part of globals (recursively) ...
[01:28:08.551] resolve() on list ...
[01:28:08.551]  recursive: 99
[01:28:08.551]  length: 1
[01:28:08.551]  elements: 'pkg'
[01:28:08.552]  length: 0 (resolved future 1)
[01:28:08.552] resolve() on list ... DONE
[01:28:08.552] - globals: [1] 'pkg'
[01:28:08.552] Resolving futures part of globals (recursively) ... DONE
[01:28:08.552] The total size of the 1 globals is 112 bytes (112 bytes)
[01:28:08.553] The total size of the 1 globals exported for future expression ('{; pkg; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'pkg' (112 bytes of class 'character')
[01:28:08.553] - globals: [1] 'pkg'
[01:28:08.553] 
[01:28:08.553] getGlobalsAndPackages() ... DONE
[01:28:08.554] Packages needed by the future expression (n = 0): <none>
[01:28:08.554] Packages needed by future strategies (n = 0): <none>
[01:28:08.554] {
[01:28:08.554]     {
[01:28:08.554]         {
[01:28:08.554]             ...future.startTime <- base::Sys.time()
[01:28:08.554]             {
[01:28:08.554]                 {
[01:28:08.554]                   {
[01:28:08.554]                     base::local({
[01:28:08.554]                       has_future <- base::requireNamespace("future", 
[01:28:08.554]                         quietly = TRUE)
[01:28:08.554]                       if (has_future) {
[01:28:08.554]                         ns <- base::getNamespace("future")
[01:28:08.554]                         version <- ns[[".package"]][["version"]]
[01:28:08.554]                         if (is.null(version)) 
[01:28:08.554]                           version <- utils::packageVersion("future")
[01:28:08.554]                       }
[01:28:08.554]                       else {
[01:28:08.554]                         version <- NULL
[01:28:08.554]                       }
[01:28:08.554]                       if (!has_future || version < "1.8.0") {
[01:28:08.554]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.554]                           "", base::R.version$version.string), 
[01:28:08.554]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.554]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.554]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.554]                             "release", "version")], collapse = " "), 
[01:28:08.554]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.554]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.554]                           info)
[01:28:08.554]                         info <- base::paste(info, collapse = "; ")
[01:28:08.554]                         if (!has_future) {
[01:28:08.554]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.554]                             info)
[01:28:08.554]                         }
[01:28:08.554]                         else {
[01:28:08.554]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.554]                             info, version)
[01:28:08.554]                         }
[01:28:08.554]                         base::stop(msg)
[01:28:08.554]                       }
[01:28:08.554]                     })
[01:28:08.554]                   }
[01:28:08.554]                   options(future.plan = NULL)
[01:28:08.554]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.554]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.554]                 }
[01:28:08.554]                 ...future.workdir <- getwd()
[01:28:08.554]             }
[01:28:08.554]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.554]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.554]         }
[01:28:08.554]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.554]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.554]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.554]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.554]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.554]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.554]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.554]             base::names(...future.oldOptions))
[01:28:08.554]     }
[01:28:08.554]     if (FALSE) {
[01:28:08.554]     }
[01:28:08.554]     else {
[01:28:08.554]         if (TRUE) {
[01:28:08.554]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.554]                 open = "w")
[01:28:08.554]         }
[01:28:08.554]         else {
[01:28:08.554]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.554]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.554]         }
[01:28:08.554]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.554]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.554]             base::sink(type = "output", split = FALSE)
[01:28:08.554]             base::close(...future.stdout)
[01:28:08.554]         }, add = TRUE)
[01:28:08.554]     }
[01:28:08.554]     ...future.frame <- base::sys.nframe()
[01:28:08.554]     ...future.conditions <- base::list()
[01:28:08.554]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.554]     if (FALSE) {
[01:28:08.554]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.554]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.554]     }
[01:28:08.554]     ...future.result <- base::tryCatch({
[01:28:08.554]         base::withCallingHandlers({
[01:28:08.554]             ...future.value <- base::withVisible(base::local({
[01:28:08.554]                 pkg
[01:28:08.554]             }))
[01:28:08.554]             future::FutureResult(value = ...future.value$value, 
[01:28:08.554]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.554]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.554]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.554]                     ...future.globalenv.names))
[01:28:08.554]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.554]         }, condition = base::local({
[01:28:08.554]             c <- base::c
[01:28:08.554]             inherits <- base::inherits
[01:28:08.554]             invokeRestart <- base::invokeRestart
[01:28:08.554]             length <- base::length
[01:28:08.554]             list <- base::list
[01:28:08.554]             seq.int <- base::seq.int
[01:28:08.554]             signalCondition <- base::signalCondition
[01:28:08.554]             sys.calls <- base::sys.calls
[01:28:08.554]             `[[` <- base::`[[`
[01:28:08.554]             `+` <- base::`+`
[01:28:08.554]             `<<-` <- base::`<<-`
[01:28:08.554]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.554]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.554]                   3L)]
[01:28:08.554]             }
[01:28:08.554]             function(cond) {
[01:28:08.554]                 is_error <- inherits(cond, "error")
[01:28:08.554]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.554]                   NULL)
[01:28:08.554]                 if (is_error) {
[01:28:08.554]                   sessionInformation <- function() {
[01:28:08.554]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.554]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.554]                       search = base::search(), system = base::Sys.info())
[01:28:08.554]                   }
[01:28:08.554]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.554]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.554]                     cond$call), session = sessionInformation(), 
[01:28:08.554]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.554]                   signalCondition(cond)
[01:28:08.554]                 }
[01:28:08.554]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.554]                 "immediateCondition"))) {
[01:28:08.554]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.554]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.554]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.554]                   if (TRUE && !signal) {
[01:28:08.554]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.554]                     {
[01:28:08.554]                       inherits <- base::inherits
[01:28:08.554]                       invokeRestart <- base::invokeRestart
[01:28:08.554]                       is.null <- base::is.null
[01:28:08.554]                       muffled <- FALSE
[01:28:08.554]                       if (inherits(cond, "message")) {
[01:28:08.554]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.554]                         if (muffled) 
[01:28:08.554]                           invokeRestart("muffleMessage")
[01:28:08.554]                       }
[01:28:08.554]                       else if (inherits(cond, "warning")) {
[01:28:08.554]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.554]                         if (muffled) 
[01:28:08.554]                           invokeRestart("muffleWarning")
[01:28:08.554]                       }
[01:28:08.554]                       else if (inherits(cond, "condition")) {
[01:28:08.554]                         if (!is.null(pattern)) {
[01:28:08.554]                           computeRestarts <- base::computeRestarts
[01:28:08.554]                           grepl <- base::grepl
[01:28:08.554]                           restarts <- computeRestarts(cond)
[01:28:08.554]                           for (restart in restarts) {
[01:28:08.554]                             name <- restart$name
[01:28:08.554]                             if (is.null(name)) 
[01:28:08.554]                               next
[01:28:08.554]                             if (!grepl(pattern, name)) 
[01:28:08.554]                               next
[01:28:08.554]                             invokeRestart(restart)
[01:28:08.554]                             muffled <- TRUE
[01:28:08.554]                             break
[01:28:08.554]                           }
[01:28:08.554]                         }
[01:28:08.554]                       }
[01:28:08.554]                       invisible(muffled)
[01:28:08.554]                     }
[01:28:08.554]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.554]                   }
[01:28:08.554]                 }
[01:28:08.554]                 else {
[01:28:08.554]                   if (TRUE) {
[01:28:08.554]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.554]                     {
[01:28:08.554]                       inherits <- base::inherits
[01:28:08.554]                       invokeRestart <- base::invokeRestart
[01:28:08.554]                       is.null <- base::is.null
[01:28:08.554]                       muffled <- FALSE
[01:28:08.554]                       if (inherits(cond, "message")) {
[01:28:08.554]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.554]                         if (muffled) 
[01:28:08.554]                           invokeRestart("muffleMessage")
[01:28:08.554]                       }
[01:28:08.554]                       else if (inherits(cond, "warning")) {
[01:28:08.554]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.554]                         if (muffled) 
[01:28:08.554]                           invokeRestart("muffleWarning")
[01:28:08.554]                       }
[01:28:08.554]                       else if (inherits(cond, "condition")) {
[01:28:08.554]                         if (!is.null(pattern)) {
[01:28:08.554]                           computeRestarts <- base::computeRestarts
[01:28:08.554]                           grepl <- base::grepl
[01:28:08.554]                           restarts <- computeRestarts(cond)
[01:28:08.554]                           for (restart in restarts) {
[01:28:08.554]                             name <- restart$name
[01:28:08.554]                             if (is.null(name)) 
[01:28:08.554]                               next
[01:28:08.554]                             if (!grepl(pattern, name)) 
[01:28:08.554]                               next
[01:28:08.554]                             invokeRestart(restart)
[01:28:08.554]                             muffled <- TRUE
[01:28:08.554]                             break
[01:28:08.554]                           }
[01:28:08.554]                         }
[01:28:08.554]                       }
[01:28:08.554]                       invisible(muffled)
[01:28:08.554]                     }
[01:28:08.554]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.554]                   }
[01:28:08.554]                 }
[01:28:08.554]             }
[01:28:08.554]         }))
[01:28:08.554]     }, error = function(ex) {
[01:28:08.554]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.554]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.554]                 ...future.rng), started = ...future.startTime, 
[01:28:08.554]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.554]             version = "1.8"), class = "FutureResult")
[01:28:08.554]     }, finally = {
[01:28:08.554]         if (!identical(...future.workdir, getwd())) 
[01:28:08.554]             setwd(...future.workdir)
[01:28:08.554]         {
[01:28:08.554]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.554]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.554]             }
[01:28:08.554]             base::options(...future.oldOptions)
[01:28:08.554]             if (.Platform$OS.type == "windows") {
[01:28:08.554]                 old_names <- names(...future.oldEnvVars)
[01:28:08.554]                 envs <- base::Sys.getenv()
[01:28:08.554]                 names <- names(envs)
[01:28:08.554]                 common <- intersect(names, old_names)
[01:28:08.554]                 added <- setdiff(names, old_names)
[01:28:08.554]                 removed <- setdiff(old_names, names)
[01:28:08.554]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.554]                   envs[common]]
[01:28:08.554]                 NAMES <- toupper(changed)
[01:28:08.554]                 args <- list()
[01:28:08.554]                 for (kk in seq_along(NAMES)) {
[01:28:08.554]                   name <- changed[[kk]]
[01:28:08.554]                   NAME <- NAMES[[kk]]
[01:28:08.554]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.554]                     next
[01:28:08.554]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.554]                 }
[01:28:08.554]                 NAMES <- toupper(added)
[01:28:08.554]                 for (kk in seq_along(NAMES)) {
[01:28:08.554]                   name <- added[[kk]]
[01:28:08.554]                   NAME <- NAMES[[kk]]
[01:28:08.554]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.554]                     next
[01:28:08.554]                   args[[name]] <- ""
[01:28:08.554]                 }
[01:28:08.554]                 NAMES <- toupper(removed)
[01:28:08.554]                 for (kk in seq_along(NAMES)) {
[01:28:08.554]                   name <- removed[[kk]]
[01:28:08.554]                   NAME <- NAMES[[kk]]
[01:28:08.554]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.554]                     next
[01:28:08.554]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.554]                 }
[01:28:08.554]                 if (length(args) > 0) 
[01:28:08.554]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.554]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.554]             }
[01:28:08.554]             else {
[01:28:08.554]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.554]             }
[01:28:08.554]             {
[01:28:08.554]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.554]                   0L) {
[01:28:08.554]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.554]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.554]                   base::options(opts)
[01:28:08.554]                 }
[01:28:08.554]                 {
[01:28:08.554]                   {
[01:28:08.554]                     NULL
[01:28:08.554]                     RNGkind("Mersenne-Twister")
[01:28:08.554]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.554]                       inherits = FALSE)
[01:28:08.554]                   }
[01:28:08.554]                   options(future.plan = NULL)
[01:28:08.554]                   if (is.na(NA_character_)) 
[01:28:08.554]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.554]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.554]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.554]                   {
[01:28:08.554]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.554]                     if (!future$lazy) 
[01:28:08.554]                       future <- run(future)
[01:28:08.554]                     invisible(future)
[01:28:08.554]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.554]                 }
[01:28:08.554]             }
[01:28:08.554]         }
[01:28:08.554]     })
[01:28:08.554]     if (TRUE) {
[01:28:08.554]         base::sink(type = "output", split = FALSE)
[01:28:08.554]         if (TRUE) {
[01:28:08.554]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.554]         }
[01:28:08.554]         else {
[01:28:08.554]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.554]         }
[01:28:08.554]         base::close(...future.stdout)
[01:28:08.554]         ...future.stdout <- NULL
[01:28:08.554]     }
[01:28:08.554]     ...future.result$conditions <- ...future.conditions
[01:28:08.554]     ...future.result$finished <- base::Sys.time()
[01:28:08.554]     ...future.result
[01:28:08.554] }
[01:28:08.558] assign_globals() ...
[01:28:08.558] List of 1
[01:28:08.558]  $ pkg: chr "foo"
[01:28:08.558]  - attr(*, "where")=List of 1
[01:28:08.558]   ..$ pkg:<environment: R_EmptyEnv> 
[01:28:08.558]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.558]  - attr(*, "resolved")= logi TRUE
[01:28:08.558]  - attr(*, "total_size")= num 112
[01:28:08.561] - copied 'pkg' to environment
[01:28:08.561] assign_globals() ... done
[01:28:08.561] plan(): Setting new future strategy stack:
[01:28:08.561] List of future strategies:
[01:28:08.561] 1. sequential:
[01:28:08.561]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.561]    - tweaked: FALSE
[01:28:08.561]    - call: NULL
[01:28:08.562] plan(): nbrOfWorkers() = 1
[01:28:08.563] plan(): Setting new future strategy stack:
[01:28:08.563] List of future strategies:
[01:28:08.563] 1. sequential:
[01:28:08.563]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.563]    - tweaked: FALSE
[01:28:08.563]    - call: plan(strategy)
[01:28:08.564] plan(): nbrOfWorkers() = 1
[01:28:08.564] SequentialFuture started (and completed)
value(f) = 'foo'
Method for identifying globals: 'ordered' ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.565] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.565] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.567] - globals found: [3] '{', '<-', '+'
[01:28:08.567] Searching for globals ... DONE
[01:28:08.567] Resolving globals: TRUE
[01:28:08.568] Resolving any globals that are futures ...
[01:28:08.568] - globals: [3] '{', '<-', '+'
[01:28:08.568] Resolving any globals that are futures ... DONE
[01:28:08.568] 
[01:28:08.568] 
[01:28:08.569] getGlobalsAndPackages() ... DONE
[01:28:08.569] run() for 'Future' ...
[01:28:08.569] - state: 'created'
[01:28:08.569] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.570] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.570] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.570]   - Field: 'label'
[01:28:08.570]   - Field: 'local'
[01:28:08.570]   - Field: 'owner'
[01:28:08.571]   - Field: 'envir'
[01:28:08.571]   - Field: 'packages'
[01:28:08.571]   - Field: 'gc'
[01:28:08.572]   - Field: 'conditions'
[01:28:08.572]   - Field: 'expr'
[01:28:08.572]   - Field: 'uuid'
[01:28:08.573]   - Field: 'seed'
[01:28:08.573]   - Field: 'version'
[01:28:08.573]   - Field: 'result'
[01:28:08.573]   - Field: 'asynchronous'
[01:28:08.573]   - Field: 'calls'
[01:28:08.573]   - Field: 'globals'
[01:28:08.574]   - Field: 'stdout'
[01:28:08.574]   - Field: 'earlySignal'
[01:28:08.574]   - Field: 'lazy'
[01:28:08.574]   - Field: 'state'
[01:28:08.574] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.574] - Launch lazy future ...
[01:28:08.575] Packages needed by the future expression (n = 0): <none>
[01:28:08.575] Packages needed by future strategies (n = 0): <none>
[01:28:08.575] {
[01:28:08.575]     {
[01:28:08.575]         {
[01:28:08.575]             ...future.startTime <- base::Sys.time()
[01:28:08.575]             {
[01:28:08.575]                 {
[01:28:08.575]                   {
[01:28:08.575]                     base::local({
[01:28:08.575]                       has_future <- base::requireNamespace("future", 
[01:28:08.575]                         quietly = TRUE)
[01:28:08.575]                       if (has_future) {
[01:28:08.575]                         ns <- base::getNamespace("future")
[01:28:08.575]                         version <- ns[[".package"]][["version"]]
[01:28:08.575]                         if (is.null(version)) 
[01:28:08.575]                           version <- utils::packageVersion("future")
[01:28:08.575]                       }
[01:28:08.575]                       else {
[01:28:08.575]                         version <- NULL
[01:28:08.575]                       }
[01:28:08.575]                       if (!has_future || version < "1.8.0") {
[01:28:08.575]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.575]                           "", base::R.version$version.string), 
[01:28:08.575]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.575]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.575]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.575]                             "release", "version")], collapse = " "), 
[01:28:08.575]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.575]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.575]                           info)
[01:28:08.575]                         info <- base::paste(info, collapse = "; ")
[01:28:08.575]                         if (!has_future) {
[01:28:08.575]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.575]                             info)
[01:28:08.575]                         }
[01:28:08.575]                         else {
[01:28:08.575]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.575]                             info, version)
[01:28:08.575]                         }
[01:28:08.575]                         base::stop(msg)
[01:28:08.575]                       }
[01:28:08.575]                     })
[01:28:08.575]                   }
[01:28:08.575]                   options(future.plan = NULL)
[01:28:08.575]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.575]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.575]                 }
[01:28:08.575]                 ...future.workdir <- getwd()
[01:28:08.575]             }
[01:28:08.575]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.575]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.575]         }
[01:28:08.575]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.575]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.575]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.575]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.575]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.575]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.575]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.575]             base::names(...future.oldOptions))
[01:28:08.575]     }
[01:28:08.575]     if (FALSE) {
[01:28:08.575]     }
[01:28:08.575]     else {
[01:28:08.575]         if (TRUE) {
[01:28:08.575]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.575]                 open = "w")
[01:28:08.575]         }
[01:28:08.575]         else {
[01:28:08.575]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.575]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.575]         }
[01:28:08.575]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.575]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.575]             base::sink(type = "output", split = FALSE)
[01:28:08.575]             base::close(...future.stdout)
[01:28:08.575]         }, add = TRUE)
[01:28:08.575]     }
[01:28:08.575]     ...future.frame <- base::sys.nframe()
[01:28:08.575]     ...future.conditions <- base::list()
[01:28:08.575]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.575]     if (FALSE) {
[01:28:08.575]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.575]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.575]     }
[01:28:08.575]     ...future.result <- base::tryCatch({
[01:28:08.575]         base::withCallingHandlers({
[01:28:08.575]             ...future.value <- base::withVisible(base::local({
[01:28:08.575]                 x <- 0
[01:28:08.575]                 x <- x + 1
[01:28:08.575]                 x
[01:28:08.575]             }))
[01:28:08.575]             future::FutureResult(value = ...future.value$value, 
[01:28:08.575]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.575]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.575]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.575]                     ...future.globalenv.names))
[01:28:08.575]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.575]         }, condition = base::local({
[01:28:08.575]             c <- base::c
[01:28:08.575]             inherits <- base::inherits
[01:28:08.575]             invokeRestart <- base::invokeRestart
[01:28:08.575]             length <- base::length
[01:28:08.575]             list <- base::list
[01:28:08.575]             seq.int <- base::seq.int
[01:28:08.575]             signalCondition <- base::signalCondition
[01:28:08.575]             sys.calls <- base::sys.calls
[01:28:08.575]             `[[` <- base::`[[`
[01:28:08.575]             `+` <- base::`+`
[01:28:08.575]             `<<-` <- base::`<<-`
[01:28:08.575]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.575]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.575]                   3L)]
[01:28:08.575]             }
[01:28:08.575]             function(cond) {
[01:28:08.575]                 is_error <- inherits(cond, "error")
[01:28:08.575]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.575]                   NULL)
[01:28:08.575]                 if (is_error) {
[01:28:08.575]                   sessionInformation <- function() {
[01:28:08.575]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.575]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.575]                       search = base::search(), system = base::Sys.info())
[01:28:08.575]                   }
[01:28:08.575]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.575]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.575]                     cond$call), session = sessionInformation(), 
[01:28:08.575]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.575]                   signalCondition(cond)
[01:28:08.575]                 }
[01:28:08.575]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.575]                 "immediateCondition"))) {
[01:28:08.575]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.575]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.575]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.575]                   if (TRUE && !signal) {
[01:28:08.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.575]                     {
[01:28:08.575]                       inherits <- base::inherits
[01:28:08.575]                       invokeRestart <- base::invokeRestart
[01:28:08.575]                       is.null <- base::is.null
[01:28:08.575]                       muffled <- FALSE
[01:28:08.575]                       if (inherits(cond, "message")) {
[01:28:08.575]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.575]                         if (muffled) 
[01:28:08.575]                           invokeRestart("muffleMessage")
[01:28:08.575]                       }
[01:28:08.575]                       else if (inherits(cond, "warning")) {
[01:28:08.575]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.575]                         if (muffled) 
[01:28:08.575]                           invokeRestart("muffleWarning")
[01:28:08.575]                       }
[01:28:08.575]                       else if (inherits(cond, "condition")) {
[01:28:08.575]                         if (!is.null(pattern)) {
[01:28:08.575]                           computeRestarts <- base::computeRestarts
[01:28:08.575]                           grepl <- base::grepl
[01:28:08.575]                           restarts <- computeRestarts(cond)
[01:28:08.575]                           for (restart in restarts) {
[01:28:08.575]                             name <- restart$name
[01:28:08.575]                             if (is.null(name)) 
[01:28:08.575]                               next
[01:28:08.575]                             if (!grepl(pattern, name)) 
[01:28:08.575]                               next
[01:28:08.575]                             invokeRestart(restart)
[01:28:08.575]                             muffled <- TRUE
[01:28:08.575]                             break
[01:28:08.575]                           }
[01:28:08.575]                         }
[01:28:08.575]                       }
[01:28:08.575]                       invisible(muffled)
[01:28:08.575]                     }
[01:28:08.575]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.575]                   }
[01:28:08.575]                 }
[01:28:08.575]                 else {
[01:28:08.575]                   if (TRUE) {
[01:28:08.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.575]                     {
[01:28:08.575]                       inherits <- base::inherits
[01:28:08.575]                       invokeRestart <- base::invokeRestart
[01:28:08.575]                       is.null <- base::is.null
[01:28:08.575]                       muffled <- FALSE
[01:28:08.575]                       if (inherits(cond, "message")) {
[01:28:08.575]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.575]                         if (muffled) 
[01:28:08.575]                           invokeRestart("muffleMessage")
[01:28:08.575]                       }
[01:28:08.575]                       else if (inherits(cond, "warning")) {
[01:28:08.575]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.575]                         if (muffled) 
[01:28:08.575]                           invokeRestart("muffleWarning")
[01:28:08.575]                       }
[01:28:08.575]                       else if (inherits(cond, "condition")) {
[01:28:08.575]                         if (!is.null(pattern)) {
[01:28:08.575]                           computeRestarts <- base::computeRestarts
[01:28:08.575]                           grepl <- base::grepl
[01:28:08.575]                           restarts <- computeRestarts(cond)
[01:28:08.575]                           for (restart in restarts) {
[01:28:08.575]                             name <- restart$name
[01:28:08.575]                             if (is.null(name)) 
[01:28:08.575]                               next
[01:28:08.575]                             if (!grepl(pattern, name)) 
[01:28:08.575]                               next
[01:28:08.575]                             invokeRestart(restart)
[01:28:08.575]                             muffled <- TRUE
[01:28:08.575]                             break
[01:28:08.575]                           }
[01:28:08.575]                         }
[01:28:08.575]                       }
[01:28:08.575]                       invisible(muffled)
[01:28:08.575]                     }
[01:28:08.575]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.575]                   }
[01:28:08.575]                 }
[01:28:08.575]             }
[01:28:08.575]         }))
[01:28:08.575]     }, error = function(ex) {
[01:28:08.575]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.575]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.575]                 ...future.rng), started = ...future.startTime, 
[01:28:08.575]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.575]             version = "1.8"), class = "FutureResult")
[01:28:08.575]     }, finally = {
[01:28:08.575]         if (!identical(...future.workdir, getwd())) 
[01:28:08.575]             setwd(...future.workdir)
[01:28:08.575]         {
[01:28:08.575]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.575]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.575]             }
[01:28:08.575]             base::options(...future.oldOptions)
[01:28:08.575]             if (.Platform$OS.type == "windows") {
[01:28:08.575]                 old_names <- names(...future.oldEnvVars)
[01:28:08.575]                 envs <- base::Sys.getenv()
[01:28:08.575]                 names <- names(envs)
[01:28:08.575]                 common <- intersect(names, old_names)
[01:28:08.575]                 added <- setdiff(names, old_names)
[01:28:08.575]                 removed <- setdiff(old_names, names)
[01:28:08.575]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.575]                   envs[common]]
[01:28:08.575]                 NAMES <- toupper(changed)
[01:28:08.575]                 args <- list()
[01:28:08.575]                 for (kk in seq_along(NAMES)) {
[01:28:08.575]                   name <- changed[[kk]]
[01:28:08.575]                   NAME <- NAMES[[kk]]
[01:28:08.575]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.575]                     next
[01:28:08.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.575]                 }
[01:28:08.575]                 NAMES <- toupper(added)
[01:28:08.575]                 for (kk in seq_along(NAMES)) {
[01:28:08.575]                   name <- added[[kk]]
[01:28:08.575]                   NAME <- NAMES[[kk]]
[01:28:08.575]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.575]                     next
[01:28:08.575]                   args[[name]] <- ""
[01:28:08.575]                 }
[01:28:08.575]                 NAMES <- toupper(removed)
[01:28:08.575]                 for (kk in seq_along(NAMES)) {
[01:28:08.575]                   name <- removed[[kk]]
[01:28:08.575]                   NAME <- NAMES[[kk]]
[01:28:08.575]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.575]                     next
[01:28:08.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.575]                 }
[01:28:08.575]                 if (length(args) > 0) 
[01:28:08.575]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.575]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.575]             }
[01:28:08.575]             else {
[01:28:08.575]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.575]             }
[01:28:08.575]             {
[01:28:08.575]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.575]                   0L) {
[01:28:08.575]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.575]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.575]                   base::options(opts)
[01:28:08.575]                 }
[01:28:08.575]                 {
[01:28:08.575]                   {
[01:28:08.575]                     NULL
[01:28:08.575]                     RNGkind("Mersenne-Twister")
[01:28:08.575]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.575]                       inherits = FALSE)
[01:28:08.575]                   }
[01:28:08.575]                   options(future.plan = NULL)
[01:28:08.575]                   if (is.na(NA_character_)) 
[01:28:08.575]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.575]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.575]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.575]                   {
[01:28:08.575]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.575]                     if (!future$lazy) 
[01:28:08.575]                       future <- run(future)
[01:28:08.575]                     invisible(future)
[01:28:08.575]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.575]                 }
[01:28:08.575]             }
[01:28:08.575]         }
[01:28:08.575]     })
[01:28:08.575]     if (TRUE) {
[01:28:08.575]         base::sink(type = "output", split = FALSE)
[01:28:08.575]         if (TRUE) {
[01:28:08.575]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.575]         }
[01:28:08.575]         else {
[01:28:08.575]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.575]         }
[01:28:08.575]         base::close(...future.stdout)
[01:28:08.575]         ...future.stdout <- NULL
[01:28:08.575]     }
[01:28:08.575]     ...future.result$conditions <- ...future.conditions
[01:28:08.575]     ...future.result$finished <- base::Sys.time()
[01:28:08.575]     ...future.result
[01:28:08.575] }
[01:28:08.579] plan(): Setting new future strategy stack:
[01:28:08.580] List of future strategies:
[01:28:08.580] 1. sequential:
[01:28:08.580]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.580]    - tweaked: FALSE
[01:28:08.580]    - call: NULL
[01:28:08.580] plan(): nbrOfWorkers() = 1
[01:28:08.581] plan(): Setting new future strategy stack:
[01:28:08.581] List of future strategies:
[01:28:08.581] 1. sequential:
[01:28:08.581]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.581]    - tweaked: FALSE
[01:28:08.581]    - call: plan(strategy)
[01:28:08.582] plan(): nbrOfWorkers() = 1
[01:28:08.582] SequentialFuture started (and completed)
[01:28:08.582] - Launch lazy future ... done
[01:28:08.583] run() for 'SequentialFuture' ... done
value(f) = '1'
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.583] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.584] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.585] - globals found: [4] '{', '<-', 'x', '+'
[01:28:08.585] Searching for globals ... DONE
[01:28:08.586] Resolving globals: TRUE
[01:28:08.586] Resolving any globals that are futures ...
[01:28:08.586] - globals: [4] '{', '<-', 'x', '+'
[01:28:08.586] Resolving any globals that are futures ... DONE
[01:28:08.587] Resolving futures part of globals (recursively) ...
[01:28:08.587] resolve() on list ...
[01:28:08.587]  recursive: 99
[01:28:08.587]  length: 1
[01:28:08.587]  elements: 'x'
[01:28:08.588]  length: 0 (resolved future 1)
[01:28:08.588] resolve() on list ... DONE
[01:28:08.588] - globals: [1] 'x'
[01:28:08.588] Resolving futures part of globals (recursively) ... DONE
[01:28:08.588] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:08.589] The total size of the 1 globals exported for future expression ('{; x <- x + 1; x; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (56 bytes of class 'numeric')
[01:28:08.589] - globals: [1] 'x'
[01:28:08.589] 
[01:28:08.589] getGlobalsAndPackages() ... DONE
[01:28:08.589] run() for 'Future' ...
[01:28:08.590] - state: 'created'
[01:28:08.590] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.590] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.590] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.591]   - Field: 'label'
[01:28:08.591]   - Field: 'local'
[01:28:08.591]   - Field: 'owner'
[01:28:08.591]   - Field: 'envir'
[01:28:08.591]   - Field: 'packages'
[01:28:08.592]   - Field: 'gc'
[01:28:08.592]   - Field: 'conditions'
[01:28:08.592]   - Field: 'expr'
[01:28:08.592]   - Field: 'uuid'
[01:28:08.592]   - Field: 'seed'
[01:28:08.592]   - Field: 'version'
[01:28:08.593]   - Field: 'result'
[01:28:08.593]   - Field: 'asynchronous'
[01:28:08.593]   - Field: 'calls'
[01:28:08.593]   - Field: 'globals'
[01:28:08.593]   - Field: 'stdout'
[01:28:08.593]   - Field: 'earlySignal'
[01:28:08.594]   - Field: 'lazy'
[01:28:08.594]   - Field: 'state'
[01:28:08.594] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.594] - Launch lazy future ...
[01:28:08.594] Packages needed by the future expression (n = 0): <none>
[01:28:08.595] Packages needed by future strategies (n = 0): <none>
[01:28:08.595] {
[01:28:08.595]     {
[01:28:08.595]         {
[01:28:08.595]             ...future.startTime <- base::Sys.time()
[01:28:08.595]             {
[01:28:08.595]                 {
[01:28:08.595]                   {
[01:28:08.595]                     base::local({
[01:28:08.595]                       has_future <- base::requireNamespace("future", 
[01:28:08.595]                         quietly = TRUE)
[01:28:08.595]                       if (has_future) {
[01:28:08.595]                         ns <- base::getNamespace("future")
[01:28:08.595]                         version <- ns[[".package"]][["version"]]
[01:28:08.595]                         if (is.null(version)) 
[01:28:08.595]                           version <- utils::packageVersion("future")
[01:28:08.595]                       }
[01:28:08.595]                       else {
[01:28:08.595]                         version <- NULL
[01:28:08.595]                       }
[01:28:08.595]                       if (!has_future || version < "1.8.0") {
[01:28:08.595]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.595]                           "", base::R.version$version.string), 
[01:28:08.595]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.595]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.595]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.595]                             "release", "version")], collapse = " "), 
[01:28:08.595]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.595]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.595]                           info)
[01:28:08.595]                         info <- base::paste(info, collapse = "; ")
[01:28:08.595]                         if (!has_future) {
[01:28:08.595]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.595]                             info)
[01:28:08.595]                         }
[01:28:08.595]                         else {
[01:28:08.595]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.595]                             info, version)
[01:28:08.595]                         }
[01:28:08.595]                         base::stop(msg)
[01:28:08.595]                       }
[01:28:08.595]                     })
[01:28:08.595]                   }
[01:28:08.595]                   options(future.plan = NULL)
[01:28:08.595]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.595]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.595]                 }
[01:28:08.595]                 ...future.workdir <- getwd()
[01:28:08.595]             }
[01:28:08.595]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.595]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.595]         }
[01:28:08.595]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.595]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.595]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.595]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.595]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.595]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.595]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.595]             base::names(...future.oldOptions))
[01:28:08.595]     }
[01:28:08.595]     if (FALSE) {
[01:28:08.595]     }
[01:28:08.595]     else {
[01:28:08.595]         if (TRUE) {
[01:28:08.595]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.595]                 open = "w")
[01:28:08.595]         }
[01:28:08.595]         else {
[01:28:08.595]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.595]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.595]         }
[01:28:08.595]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.595]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.595]             base::sink(type = "output", split = FALSE)
[01:28:08.595]             base::close(...future.stdout)
[01:28:08.595]         }, add = TRUE)
[01:28:08.595]     }
[01:28:08.595]     ...future.frame <- base::sys.nframe()
[01:28:08.595]     ...future.conditions <- base::list()
[01:28:08.595]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.595]     if (FALSE) {
[01:28:08.595]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.595]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.595]     }
[01:28:08.595]     ...future.result <- base::tryCatch({
[01:28:08.595]         base::withCallingHandlers({
[01:28:08.595]             ...future.value <- base::withVisible(base::local({
[01:28:08.595]                 x <- x + 1
[01:28:08.595]                 x
[01:28:08.595]             }))
[01:28:08.595]             future::FutureResult(value = ...future.value$value, 
[01:28:08.595]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.595]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.595]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.595]                     ...future.globalenv.names))
[01:28:08.595]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.595]         }, condition = base::local({
[01:28:08.595]             c <- base::c
[01:28:08.595]             inherits <- base::inherits
[01:28:08.595]             invokeRestart <- base::invokeRestart
[01:28:08.595]             length <- base::length
[01:28:08.595]             list <- base::list
[01:28:08.595]             seq.int <- base::seq.int
[01:28:08.595]             signalCondition <- base::signalCondition
[01:28:08.595]             sys.calls <- base::sys.calls
[01:28:08.595]             `[[` <- base::`[[`
[01:28:08.595]             `+` <- base::`+`
[01:28:08.595]             `<<-` <- base::`<<-`
[01:28:08.595]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.595]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.595]                   3L)]
[01:28:08.595]             }
[01:28:08.595]             function(cond) {
[01:28:08.595]                 is_error <- inherits(cond, "error")
[01:28:08.595]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.595]                   NULL)
[01:28:08.595]                 if (is_error) {
[01:28:08.595]                   sessionInformation <- function() {
[01:28:08.595]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.595]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.595]                       search = base::search(), system = base::Sys.info())
[01:28:08.595]                   }
[01:28:08.595]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.595]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.595]                     cond$call), session = sessionInformation(), 
[01:28:08.595]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.595]                   signalCondition(cond)
[01:28:08.595]                 }
[01:28:08.595]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.595]                 "immediateCondition"))) {
[01:28:08.595]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.595]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.595]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.595]                   if (TRUE && !signal) {
[01:28:08.595]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.595]                     {
[01:28:08.595]                       inherits <- base::inherits
[01:28:08.595]                       invokeRestart <- base::invokeRestart
[01:28:08.595]                       is.null <- base::is.null
[01:28:08.595]                       muffled <- FALSE
[01:28:08.595]                       if (inherits(cond, "message")) {
[01:28:08.595]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.595]                         if (muffled) 
[01:28:08.595]                           invokeRestart("muffleMessage")
[01:28:08.595]                       }
[01:28:08.595]                       else if (inherits(cond, "warning")) {
[01:28:08.595]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.595]                         if (muffled) 
[01:28:08.595]                           invokeRestart("muffleWarning")
[01:28:08.595]                       }
[01:28:08.595]                       else if (inherits(cond, "condition")) {
[01:28:08.595]                         if (!is.null(pattern)) {
[01:28:08.595]                           computeRestarts <- base::computeRestarts
[01:28:08.595]                           grepl <- base::grepl
[01:28:08.595]                           restarts <- computeRestarts(cond)
[01:28:08.595]                           for (restart in restarts) {
[01:28:08.595]                             name <- restart$name
[01:28:08.595]                             if (is.null(name)) 
[01:28:08.595]                               next
[01:28:08.595]                             if (!grepl(pattern, name)) 
[01:28:08.595]                               next
[01:28:08.595]                             invokeRestart(restart)
[01:28:08.595]                             muffled <- TRUE
[01:28:08.595]                             break
[01:28:08.595]                           }
[01:28:08.595]                         }
[01:28:08.595]                       }
[01:28:08.595]                       invisible(muffled)
[01:28:08.595]                     }
[01:28:08.595]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.595]                   }
[01:28:08.595]                 }
[01:28:08.595]                 else {
[01:28:08.595]                   if (TRUE) {
[01:28:08.595]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.595]                     {
[01:28:08.595]                       inherits <- base::inherits
[01:28:08.595]                       invokeRestart <- base::invokeRestart
[01:28:08.595]                       is.null <- base::is.null
[01:28:08.595]                       muffled <- FALSE
[01:28:08.595]                       if (inherits(cond, "message")) {
[01:28:08.595]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.595]                         if (muffled) 
[01:28:08.595]                           invokeRestart("muffleMessage")
[01:28:08.595]                       }
[01:28:08.595]                       else if (inherits(cond, "warning")) {
[01:28:08.595]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.595]                         if (muffled) 
[01:28:08.595]                           invokeRestart("muffleWarning")
[01:28:08.595]                       }
[01:28:08.595]                       else if (inherits(cond, "condition")) {
[01:28:08.595]                         if (!is.null(pattern)) {
[01:28:08.595]                           computeRestarts <- base::computeRestarts
[01:28:08.595]                           grepl <- base::grepl
[01:28:08.595]                           restarts <- computeRestarts(cond)
[01:28:08.595]                           for (restart in restarts) {
[01:28:08.595]                             name <- restart$name
[01:28:08.595]                             if (is.null(name)) 
[01:28:08.595]                               next
[01:28:08.595]                             if (!grepl(pattern, name)) 
[01:28:08.595]                               next
[01:28:08.595]                             invokeRestart(restart)
[01:28:08.595]                             muffled <- TRUE
[01:28:08.595]                             break
[01:28:08.595]                           }
[01:28:08.595]                         }
[01:28:08.595]                       }
[01:28:08.595]                       invisible(muffled)
[01:28:08.595]                     }
[01:28:08.595]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.595]                   }
[01:28:08.595]                 }
[01:28:08.595]             }
[01:28:08.595]         }))
[01:28:08.595]     }, error = function(ex) {
[01:28:08.595]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.595]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.595]                 ...future.rng), started = ...future.startTime, 
[01:28:08.595]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.595]             version = "1.8"), class = "FutureResult")
[01:28:08.595]     }, finally = {
[01:28:08.595]         if (!identical(...future.workdir, getwd())) 
[01:28:08.595]             setwd(...future.workdir)
[01:28:08.595]         {
[01:28:08.595]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.595]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.595]             }
[01:28:08.595]             base::options(...future.oldOptions)
[01:28:08.595]             if (.Platform$OS.type == "windows") {
[01:28:08.595]                 old_names <- names(...future.oldEnvVars)
[01:28:08.595]                 envs <- base::Sys.getenv()
[01:28:08.595]                 names <- names(envs)
[01:28:08.595]                 common <- intersect(names, old_names)
[01:28:08.595]                 added <- setdiff(names, old_names)
[01:28:08.595]                 removed <- setdiff(old_names, names)
[01:28:08.595]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.595]                   envs[common]]
[01:28:08.595]                 NAMES <- toupper(changed)
[01:28:08.595]                 args <- list()
[01:28:08.595]                 for (kk in seq_along(NAMES)) {
[01:28:08.595]                   name <- changed[[kk]]
[01:28:08.595]                   NAME <- NAMES[[kk]]
[01:28:08.595]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.595]                     next
[01:28:08.595]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.595]                 }
[01:28:08.595]                 NAMES <- toupper(added)
[01:28:08.595]                 for (kk in seq_along(NAMES)) {
[01:28:08.595]                   name <- added[[kk]]
[01:28:08.595]                   NAME <- NAMES[[kk]]
[01:28:08.595]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.595]                     next
[01:28:08.595]                   args[[name]] <- ""
[01:28:08.595]                 }
[01:28:08.595]                 NAMES <- toupper(removed)
[01:28:08.595]                 for (kk in seq_along(NAMES)) {
[01:28:08.595]                   name <- removed[[kk]]
[01:28:08.595]                   NAME <- NAMES[[kk]]
[01:28:08.595]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.595]                     next
[01:28:08.595]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.595]                 }
[01:28:08.595]                 if (length(args) > 0) 
[01:28:08.595]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.595]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.595]             }
[01:28:08.595]             else {
[01:28:08.595]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.595]             }
[01:28:08.595]             {
[01:28:08.595]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.595]                   0L) {
[01:28:08.595]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.595]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.595]                   base::options(opts)
[01:28:08.595]                 }
[01:28:08.595]                 {
[01:28:08.595]                   {
[01:28:08.595]                     NULL
[01:28:08.595]                     RNGkind("Mersenne-Twister")
[01:28:08.595]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.595]                       inherits = FALSE)
[01:28:08.595]                   }
[01:28:08.595]                   options(future.plan = NULL)
[01:28:08.595]                   if (is.na(NA_character_)) 
[01:28:08.595]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.595]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.595]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.595]                   {
[01:28:08.595]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.595]                     if (!future$lazy) 
[01:28:08.595]                       future <- run(future)
[01:28:08.595]                     invisible(future)
[01:28:08.595]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.595]                 }
[01:28:08.595]             }
[01:28:08.595]         }
[01:28:08.595]     })
[01:28:08.595]     if (TRUE) {
[01:28:08.595]         base::sink(type = "output", split = FALSE)
[01:28:08.595]         if (TRUE) {
[01:28:08.595]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.595]         }
[01:28:08.595]         else {
[01:28:08.595]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.595]         }
[01:28:08.595]         base::close(...future.stdout)
[01:28:08.595]         ...future.stdout <- NULL
[01:28:08.595]     }
[01:28:08.595]     ...future.result$conditions <- ...future.conditions
[01:28:08.595]     ...future.result$finished <- base::Sys.time()
[01:28:08.595]     ...future.result
[01:28:08.595] }
[01:28:08.599] assign_globals() ...
[01:28:08.600] List of 1
[01:28:08.600]  $ x: num 1
[01:28:08.600]  - attr(*, "where")=List of 1
[01:28:08.600]   ..$ x:<environment: R_EmptyEnv> 
[01:28:08.600]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.600]  - attr(*, "resolved")= logi TRUE
[01:28:08.600]  - attr(*, "total_size")= num 56
[01:28:08.600]  - attr(*, "already-done")= logi TRUE
[01:28:08.603] - copied 'x' to environment
[01:28:08.603] assign_globals() ... done
[01:28:08.603] plan(): Setting new future strategy stack:
[01:28:08.603] List of future strategies:
[01:28:08.603] 1. sequential:
[01:28:08.603]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.603]    - tweaked: FALSE
[01:28:08.603]    - call: NULL
[01:28:08.604] plan(): nbrOfWorkers() = 1
[01:28:08.605] plan(): Setting new future strategy stack:
[01:28:08.605] List of future strategies:
[01:28:08.605] 1. sequential:
[01:28:08.605]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.605]    - tweaked: FALSE
[01:28:08.605]    - call: plan(strategy)
[01:28:08.606] plan(): nbrOfWorkers() = 1
[01:28:08.606] SequentialFuture started (and completed)
[01:28:08.606] - Launch lazy future ... done
[01:28:08.607] run() for 'SequentialFuture' ... done
value(f) = '2'
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.607] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.607] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:08.611] - globals found: [3] '{', '<-', 'x'
[01:28:08.611] Searching for globals ... DONE
[01:28:08.612] Resolving globals: TRUE
[01:28:08.612] Resolving any globals that are futures ...
[01:28:08.612] - globals: [3] '{', '<-', 'x'
[01:28:08.612] Resolving any globals that are futures ... DONE
[01:28:08.613] Resolving futures part of globals (recursively) ...
[01:28:08.613] resolve() on list ...
[01:28:08.613]  recursive: 99
[01:28:08.613]  length: 1
[01:28:08.613]  elements: 'x'
[01:28:08.614]  length: 0 (resolved future 1)
[01:28:08.614] resolve() on list ... DONE
[01:28:08.614] - globals: [1] 'x'
[01:28:08.614] Resolving futures part of globals (recursively) ... DONE
[01:28:08.614] The total size of the 1 globals is 1.01 KiB (1032 bytes)
[01:28:08.615] The total size of the 1 globals exported for future expression ('{; x <- x(); x; }') is 1.01 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (1.01 KiB of class 'function')
[01:28:08.615] - globals: [1] 'x'
[01:28:08.615] 
[01:28:08.615] getGlobalsAndPackages() ... DONE
[01:28:08.616] run() for 'Future' ...
[01:28:08.616] - state: 'created'
[01:28:08.616] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:08.616] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:08.617] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:08.617]   - Field: 'label'
[01:28:08.617]   - Field: 'local'
[01:28:08.617]   - Field: 'owner'
[01:28:08.617]   - Field: 'envir'
[01:28:08.618]   - Field: 'packages'
[01:28:08.618]   - Field: 'gc'
[01:28:08.618]   - Field: 'conditions'
[01:28:08.618]   - Field: 'expr'
[01:28:08.618]   - Field: 'uuid'
[01:28:08.618]   - Field: 'seed'
[01:28:08.619]   - Field: 'version'
[01:28:08.619]   - Field: 'result'
[01:28:08.619]   - Field: 'asynchronous'
[01:28:08.619]   - Field: 'calls'
[01:28:08.619]   - Field: 'globals'
[01:28:08.620]   - Field: 'stdout'
[01:28:08.620]   - Field: 'earlySignal'
[01:28:08.620]   - Field: 'lazy'
[01:28:08.620]   - Field: 'state'
[01:28:08.620] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:08.620] - Launch lazy future ...
[01:28:08.621] Packages needed by the future expression (n = 0): <none>
[01:28:08.621] Packages needed by future strategies (n = 0): <none>
[01:28:08.621] {
[01:28:08.621]     {
[01:28:08.621]         {
[01:28:08.621]             ...future.startTime <- base::Sys.time()
[01:28:08.621]             {
[01:28:08.621]                 {
[01:28:08.621]                   {
[01:28:08.621]                     base::local({
[01:28:08.621]                       has_future <- base::requireNamespace("future", 
[01:28:08.621]                         quietly = TRUE)
[01:28:08.621]                       if (has_future) {
[01:28:08.621]                         ns <- base::getNamespace("future")
[01:28:08.621]                         version <- ns[[".package"]][["version"]]
[01:28:08.621]                         if (is.null(version)) 
[01:28:08.621]                           version <- utils::packageVersion("future")
[01:28:08.621]                       }
[01:28:08.621]                       else {
[01:28:08.621]                         version <- NULL
[01:28:08.621]                       }
[01:28:08.621]                       if (!has_future || version < "1.8.0") {
[01:28:08.621]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:08.621]                           "", base::R.version$version.string), 
[01:28:08.621]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:08.621]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:08.621]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:08.621]                             "release", "version")], collapse = " "), 
[01:28:08.621]                           hostname = base::Sys.info()[["nodename"]])
[01:28:08.621]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:08.621]                           info)
[01:28:08.621]                         info <- base::paste(info, collapse = "; ")
[01:28:08.621]                         if (!has_future) {
[01:28:08.621]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:08.621]                             info)
[01:28:08.621]                         }
[01:28:08.621]                         else {
[01:28:08.621]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:08.621]                             info, version)
[01:28:08.621]                         }
[01:28:08.621]                         base::stop(msg)
[01:28:08.621]                       }
[01:28:08.621]                     })
[01:28:08.621]                   }
[01:28:08.621]                   options(future.plan = NULL)
[01:28:08.621]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.621]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:08.621]                 }
[01:28:08.621]                 ...future.workdir <- getwd()
[01:28:08.621]             }
[01:28:08.621]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:08.621]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:08.621]         }
[01:28:08.621]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:08.621]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:08.621]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:08.621]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:08.621]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:08.621]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:08.621]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:08.621]             base::names(...future.oldOptions))
[01:28:08.621]     }
[01:28:08.621]     if (FALSE) {
[01:28:08.621]     }
[01:28:08.621]     else {
[01:28:08.621]         if (TRUE) {
[01:28:08.621]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:08.621]                 open = "w")
[01:28:08.621]         }
[01:28:08.621]         else {
[01:28:08.621]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:08.621]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:08.621]         }
[01:28:08.621]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:08.621]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:08.621]             base::sink(type = "output", split = FALSE)
[01:28:08.621]             base::close(...future.stdout)
[01:28:08.621]         }, add = TRUE)
[01:28:08.621]     }
[01:28:08.621]     ...future.frame <- base::sys.nframe()
[01:28:08.621]     ...future.conditions <- base::list()
[01:28:08.621]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:08.621]     if (FALSE) {
[01:28:08.621]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:08.621]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:08.621]     }
[01:28:08.621]     ...future.result <- base::tryCatch({
[01:28:08.621]         base::withCallingHandlers({
[01:28:08.621]             ...future.value <- base::withVisible(base::local({
[01:28:08.621]                 x <- x()
[01:28:08.621]                 x
[01:28:08.621]             }))
[01:28:08.621]             future::FutureResult(value = ...future.value$value, 
[01:28:08.621]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.621]                   ...future.rng), globalenv = if (FALSE) 
[01:28:08.621]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:08.621]                     ...future.globalenv.names))
[01:28:08.621]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:08.621]         }, condition = base::local({
[01:28:08.621]             c <- base::c
[01:28:08.621]             inherits <- base::inherits
[01:28:08.621]             invokeRestart <- base::invokeRestart
[01:28:08.621]             length <- base::length
[01:28:08.621]             list <- base::list
[01:28:08.621]             seq.int <- base::seq.int
[01:28:08.621]             signalCondition <- base::signalCondition
[01:28:08.621]             sys.calls <- base::sys.calls
[01:28:08.621]             `[[` <- base::`[[`
[01:28:08.621]             `+` <- base::`+`
[01:28:08.621]             `<<-` <- base::`<<-`
[01:28:08.621]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:08.621]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:08.621]                   3L)]
[01:28:08.621]             }
[01:28:08.621]             function(cond) {
[01:28:08.621]                 is_error <- inherits(cond, "error")
[01:28:08.621]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:08.621]                   NULL)
[01:28:08.621]                 if (is_error) {
[01:28:08.621]                   sessionInformation <- function() {
[01:28:08.621]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:08.621]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:08.621]                       search = base::search(), system = base::Sys.info())
[01:28:08.621]                   }
[01:28:08.621]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.621]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:08.621]                     cond$call), session = sessionInformation(), 
[01:28:08.621]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:08.621]                   signalCondition(cond)
[01:28:08.621]                 }
[01:28:08.621]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:08.621]                 "immediateCondition"))) {
[01:28:08.621]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:08.621]                   ...future.conditions[[length(...future.conditions) + 
[01:28:08.621]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:08.621]                   if (TRUE && !signal) {
[01:28:08.621]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.621]                     {
[01:28:08.621]                       inherits <- base::inherits
[01:28:08.621]                       invokeRestart <- base::invokeRestart
[01:28:08.621]                       is.null <- base::is.null
[01:28:08.621]                       muffled <- FALSE
[01:28:08.621]                       if (inherits(cond, "message")) {
[01:28:08.621]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.621]                         if (muffled) 
[01:28:08.621]                           invokeRestart("muffleMessage")
[01:28:08.621]                       }
[01:28:08.621]                       else if (inherits(cond, "warning")) {
[01:28:08.621]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.621]                         if (muffled) 
[01:28:08.621]                           invokeRestart("muffleWarning")
[01:28:08.621]                       }
[01:28:08.621]                       else if (inherits(cond, "condition")) {
[01:28:08.621]                         if (!is.null(pattern)) {
[01:28:08.621]                           computeRestarts <- base::computeRestarts
[01:28:08.621]                           grepl <- base::grepl
[01:28:08.621]                           restarts <- computeRestarts(cond)
[01:28:08.621]                           for (restart in restarts) {
[01:28:08.621]                             name <- restart$name
[01:28:08.621]                             if (is.null(name)) 
[01:28:08.621]                               next
[01:28:08.621]                             if (!grepl(pattern, name)) 
[01:28:08.621]                               next
[01:28:08.621]                             invokeRestart(restart)
[01:28:08.621]                             muffled <- TRUE
[01:28:08.621]                             break
[01:28:08.621]                           }
[01:28:08.621]                         }
[01:28:08.621]                       }
[01:28:08.621]                       invisible(muffled)
[01:28:08.621]                     }
[01:28:08.621]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.621]                   }
[01:28:08.621]                 }
[01:28:08.621]                 else {
[01:28:08.621]                   if (TRUE) {
[01:28:08.621]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:08.621]                     {
[01:28:08.621]                       inherits <- base::inherits
[01:28:08.621]                       invokeRestart <- base::invokeRestart
[01:28:08.621]                       is.null <- base::is.null
[01:28:08.621]                       muffled <- FALSE
[01:28:08.621]                       if (inherits(cond, "message")) {
[01:28:08.621]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:08.621]                         if (muffled) 
[01:28:08.621]                           invokeRestart("muffleMessage")
[01:28:08.621]                       }
[01:28:08.621]                       else if (inherits(cond, "warning")) {
[01:28:08.621]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:08.621]                         if (muffled) 
[01:28:08.621]                           invokeRestart("muffleWarning")
[01:28:08.621]                       }
[01:28:08.621]                       else if (inherits(cond, "condition")) {
[01:28:08.621]                         if (!is.null(pattern)) {
[01:28:08.621]                           computeRestarts <- base::computeRestarts
[01:28:08.621]                           grepl <- base::grepl
[01:28:08.621]                           restarts <- computeRestarts(cond)
[01:28:08.621]                           for (restart in restarts) {
[01:28:08.621]                             name <- restart$name
[01:28:08.621]                             if (is.null(name)) 
[01:28:08.621]                               next
[01:28:08.621]                             if (!grepl(pattern, name)) 
[01:28:08.621]                               next
[01:28:08.621]                             invokeRestart(restart)
[01:28:08.621]                             muffled <- TRUE
[01:28:08.621]                             break
[01:28:08.621]                           }
[01:28:08.621]                         }
[01:28:08.621]                       }
[01:28:08.621]                       invisible(muffled)
[01:28:08.621]                     }
[01:28:08.621]                     muffleCondition(cond, pattern = "^muffle")
[01:28:08.621]                   }
[01:28:08.621]                 }
[01:28:08.621]             }
[01:28:08.621]         }))
[01:28:08.621]     }, error = function(ex) {
[01:28:08.621]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:08.621]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:08.621]                 ...future.rng), started = ...future.startTime, 
[01:28:08.621]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:08.621]             version = "1.8"), class = "FutureResult")
[01:28:08.621]     }, finally = {
[01:28:08.621]         if (!identical(...future.workdir, getwd())) 
[01:28:08.621]             setwd(...future.workdir)
[01:28:08.621]         {
[01:28:08.621]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:08.621]                 ...future.oldOptions$nwarnings <- NULL
[01:28:08.621]             }
[01:28:08.621]             base::options(...future.oldOptions)
[01:28:08.621]             if (.Platform$OS.type == "windows") {
[01:28:08.621]                 old_names <- names(...future.oldEnvVars)
[01:28:08.621]                 envs <- base::Sys.getenv()
[01:28:08.621]                 names <- names(envs)
[01:28:08.621]                 common <- intersect(names, old_names)
[01:28:08.621]                 added <- setdiff(names, old_names)
[01:28:08.621]                 removed <- setdiff(old_names, names)
[01:28:08.621]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:08.621]                   envs[common]]
[01:28:08.621]                 NAMES <- toupper(changed)
[01:28:08.621]                 args <- list()
[01:28:08.621]                 for (kk in seq_along(NAMES)) {
[01:28:08.621]                   name <- changed[[kk]]
[01:28:08.621]                   NAME <- NAMES[[kk]]
[01:28:08.621]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.621]                     next
[01:28:08.621]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.621]                 }
[01:28:08.621]                 NAMES <- toupper(added)
[01:28:08.621]                 for (kk in seq_along(NAMES)) {
[01:28:08.621]                   name <- added[[kk]]
[01:28:08.621]                   NAME <- NAMES[[kk]]
[01:28:08.621]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.621]                     next
[01:28:08.621]                   args[[name]] <- ""
[01:28:08.621]                 }
[01:28:08.621]                 NAMES <- toupper(removed)
[01:28:08.621]                 for (kk in seq_along(NAMES)) {
[01:28:08.621]                   name <- removed[[kk]]
[01:28:08.621]                   NAME <- NAMES[[kk]]
[01:28:08.621]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:08.621]                     next
[01:28:08.621]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:08.621]                 }
[01:28:08.621]                 if (length(args) > 0) 
[01:28:08.621]                   base::do.call(base::Sys.setenv, args = args)
[01:28:08.621]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:08.621]             }
[01:28:08.621]             else {
[01:28:08.621]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:08.621]             }
[01:28:08.621]             {
[01:28:08.621]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:08.621]                   0L) {
[01:28:08.621]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:08.621]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:08.621]                   base::options(opts)
[01:28:08.621]                 }
[01:28:08.621]                 {
[01:28:08.621]                   {
[01:28:08.621]                     NULL
[01:28:08.621]                     RNGkind("Mersenne-Twister")
[01:28:08.621]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:08.621]                       inherits = FALSE)
[01:28:08.621]                   }
[01:28:08.621]                   options(future.plan = NULL)
[01:28:08.621]                   if (is.na(NA_character_)) 
[01:28:08.621]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:08.621]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:08.621]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:08.621]                   {
[01:28:08.621]                     future <- SequentialFuture(..., envir = envir)
[01:28:08.621]                     if (!future$lazy) 
[01:28:08.621]                       future <- run(future)
[01:28:08.621]                     invisible(future)
[01:28:08.621]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:08.621]                 }
[01:28:08.621]             }
[01:28:08.621]         }
[01:28:08.621]     })
[01:28:08.621]     if (TRUE) {
[01:28:08.621]         base::sink(type = "output", split = FALSE)
[01:28:08.621]         if (TRUE) {
[01:28:08.621]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:08.621]         }
[01:28:08.621]         else {
[01:28:08.621]             ...future.result["stdout"] <- base::list(NULL)
[01:28:08.621]         }
[01:28:08.621]         base::close(...future.stdout)
[01:28:08.621]         ...future.stdout <- NULL
[01:28:08.621]     }
[01:28:08.621]     ...future.result$conditions <- ...future.conditions
[01:28:08.621]     ...future.result$finished <- base::Sys.time()
[01:28:08.621]     ...future.result
[01:28:08.621] }
[01:28:08.625] assign_globals() ...
[01:28:08.625] List of 1
[01:28:08.625]  $ x:function ()  
[01:28:08.625]  - attr(*, "where")=List of 1
[01:28:08.625]   ..$ x:<environment: R_EmptyEnv> 
[01:28:08.625]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:08.625]  - attr(*, "resolved")= logi TRUE
[01:28:08.625]  - attr(*, "total_size")= num 1032
[01:28:08.625]  - attr(*, "already-done")= logi TRUE
[01:28:08.628] - reassign environment for 'x'
[01:28:08.628] - copied 'x' to environment
[01:28:08.629] assign_globals() ... done
[01:28:08.629] plan(): Setting new future strategy stack:
[01:28:08.629] List of future strategies:
[01:28:08.629] 1. sequential:
[01:28:08.629]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.629]    - tweaked: FALSE
[01:28:08.629]    - call: NULL
[01:28:08.630] plan(): nbrOfWorkers() = 1
[01:28:08.631] plan(): Setting new future strategy stack:
[01:28:08.631] List of future strategies:
[01:28:08.631] 1. sequential:
[01:28:08.631]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:08.631]    - tweaked: FALSE
[01:28:08.631]    - call: plan(strategy)
[01:28:08.632] plan(): nbrOfWorkers() = 1
[01:28:08.632] SequentialFuture started (and completed)
[01:28:08.632] - Launch lazy future ... done
[01:28:08.632] run() for 'SequentialFuture' ... done
value(f) = 'TRUE'
Testing with 1 cores ... DONE
Testing with 2 cores ...
availableCores(): 2
- Local variables with the same name as globals ...
- plan('multisession') ...
[01:28:08.643] plan(): Setting new future strategy stack:
[01:28:08.643] List of future strategies:
[01:28:08.643] 1. multisession:
[01:28:08.643]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:08.643]    - tweaked: FALSE
[01:28:08.643]    - call: plan(strategy)
[01:28:08.643] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:08.644] multisession:
[01:28:08.644] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:08.644] - tweaked: FALSE
[01:28:08.644] - call: plan(strategy)
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:08.649] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:08.649] Not searching for globals
[01:28:08.649] - globals: [0] <none>
[01:28:08.649] getGlobalsAndPackages() ... DONE
[01:28:08.650] [local output] makeClusterPSOCK() ...
[01:28:08.686] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:08.692] [local output] Base port: 24174
[01:28:08.692] [local output] Getting setup options for 2 cluster nodes ...
[01:28:08.693] [local output]  - Node 1 of 2 ...
[01:28:08.693] [local output] localMachine=TRUE => revtunnel=FALSE

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

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

[01:28:08.920] [local output] Rscript port: 24174

[01:28:08.921] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:08.921] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:08.922] [local output] Setting up PSOCK nodes in parallel
[01:28:08.922] List of 36
[01:28:08.922]  $ worker          : chr "localhost"
[01:28:08.922]   ..- attr(*, "localhost")= logi TRUE
[01:28:08.922]  $ master          : chr "localhost"
[01:28:08.922]  $ port            : int 24174
[01:28:08.922]  $ connectTimeout  : num 120
[01:28:08.922]  $ timeout         : num 120
[01:28:08.922]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:08.922]  $ homogeneous     : logi TRUE
[01:28:08.922]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=globals,tricky.R:6520:CRANWIN3:C"| __truncated__
[01:28:08.922]  $ rscript_envs    : NULL
[01:28:08.922]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:08.922]  $ rscript_startup : NULL
[01:28:08.922]  $ rscript_sh      : chr "cmd"
[01:28:08.922]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:08.922]  $ methods         : logi TRUE
[01:28:08.922]  $ socketOptions   : chr "no-delay"
[01:28:08.922]  $ useXDR          : logi FALSE
[01:28:08.922]  $ outfile         : chr "/dev/null"
[01:28:08.922]  $ renice          : int NA
[01:28:08.922]  $ rshcmd          : NULL
[01:28:08.922]  $ user            : chr(0) 
[01:28:08.922]  $ revtunnel       : logi FALSE
[01:28:08.922]  $ rshlogfile      : NULL
[01:28:08.922]  $ rshopts         : chr(0) 
[01:28:08.922]  $ rank            : int 1
[01:28:08.922]  $ manual          : logi FALSE
[01:28:08.922]  $ dryrun          : logi FALSE
[01:28:08.922]  $ quiet           : logi FALSE
[01:28:08.922]  $ setup_strategy  : chr "parallel"
[01:28:08.922]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:08.922]  $ pidfile         : chr "D:/temp/RtmpoVeHC6/worker.rank=1.parallelly.parent=6520.19787c54d2e.pid"
[01:28:08.922]  $ rshcmd_label    : NULL
[01:28:08.922]  $ rsh_call        : NULL
[01:28:08.922]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:08.922]  $ localMachine    : logi TRUE
[01:28:08.922]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:08.922]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:08.922]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:08.922]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:08.922]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:08.922]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:08.922]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:08.922]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:08.922]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:08.922]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:08.922]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:08.922]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:08.922]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:08.922]  $ arguments       :List of 28
[01:28:08.922]   ..$ worker          : chr "localhost"
[01:28:08.922]   ..$ master          : NULL
[01:28:08.922]   ..$ port            : int 24174
[01:28:08.922]   ..$ connectTimeout  : num 120
[01:28:08.922]   ..$ timeout         : num 120
[01:28:08.922]   ..$ rscript         : NULL
[01:28:08.922]   ..$ homogeneous     : NULL
[01:28:08.922]   ..$ rscript_args    : NULL
[01:28:08.922]   ..$ rscript_envs    : NULL
[01:28:08.922]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:08.922]   ..$ rscript_startup : NULL
[01:28:08.922]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:08.922]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:08.922]   ..$ methods         : logi TRUE
[01:28:08.922]   ..$ socketOptions   : chr "no-delay"
[01:28:08.922]   ..$ useXDR          : logi FALSE
[01:28:08.922]   ..$ outfile         : chr "/dev/null"
[01:28:08.922]   ..$ renice          : int NA
[01:28:08.922]   ..$ rshcmd          : NULL
[01:28:08.922]   ..$ user            : NULL
[01:28:08.922]   ..$ revtunnel       : logi NA
[01:28:08.922]   ..$ rshlogfile      : NULL
[01:28:08.922]   ..$ rshopts         : NULL
[01:28:08.922]   ..$ rank            : int 1
[01:28:08.922]   ..$ manual          : logi FALSE
[01:28:08.922]   ..$ dryrun          : logi FALSE
[01:28:08.922]   ..$ quiet           : logi FALSE
[01:28:08.922]   ..$ setup_strategy  : chr "parallel"
[01:28:08.922]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:08.944] [local output] System call to launch all workers:
[01:28:08.944] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=globals,tricky.R:6520:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpoVeHC6/worker.rank=1.parallelly.parent=6520.19787c54d2e.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=24174 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:08.944] [local output] Starting PSOCK main server
[01:28:08.951] [local output] Workers launched
[01:28:08.951] [local output] Waiting for workers to connect back
[01:28:08.952]  - [local output] 0 workers out of 2 ready
[01:28:09.124]  - [local output] 0 workers out of 2 ready
[01:28:09.125]  - [local output] 1 workers out of 2 ready
[01:28:09.127]  - [local output] 1 workers out of 2 ready
[01:28:09.128]  - [local output] 2 workers out of 2 ready
[01:28:09.128] [local output] Launching of workers completed
[01:28:09.128] [local output] Collecting session information from workers
[01:28:09.129] [local output]  - Worker #1 of 2
[01:28:09.130] [local output]  - Worker #2 of 2
[01:28:09.131] [local output] makeClusterPSOCK() ... done
[01:28:09.144] Packages needed by the future expression (n = 0): <none>
[01:28:09.144] Packages needed by future strategies (n = 0): <none>
[01:28:09.145] {
[01:28:09.145]     {
[01:28:09.145]         {
[01:28:09.145]             ...future.startTime <- base::Sys.time()
[01:28:09.145]             {
[01:28:09.145]                 {
[01:28:09.145]                   {
[01:28:09.145]                     {
[01:28:09.145]                       base::local({
[01:28:09.145]                         has_future <- base::requireNamespace("future", 
[01:28:09.145]                           quietly = TRUE)
[01:28:09.145]                         if (has_future) {
[01:28:09.145]                           ns <- base::getNamespace("future")
[01:28:09.145]                           version <- ns[[".package"]][["version"]]
[01:28:09.145]                           if (is.null(version)) 
[01:28:09.145]                             version <- utils::packageVersion("future")
[01:28:09.145]                         }
[01:28:09.145]                         else {
[01:28:09.145]                           version <- NULL
[01:28:09.145]                         }
[01:28:09.145]                         if (!has_future || version < "1.8.0") {
[01:28:09.145]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.145]                             "", base::R.version$version.string), 
[01:28:09.145]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.145]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.145]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.145]                               "release", "version")], collapse = " "), 
[01:28:09.145]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.145]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.145]                             info)
[01:28:09.145]                           info <- base::paste(info, collapse = "; ")
[01:28:09.145]                           if (!has_future) {
[01:28:09.145]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.145]                               info)
[01:28:09.145]                           }
[01:28:09.145]                           else {
[01:28:09.145]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.145]                               info, version)
[01:28:09.145]                           }
[01:28:09.145]                           base::stop(msg)
[01:28:09.145]                         }
[01:28:09.145]                       })
[01:28:09.145]                     }
[01:28:09.145]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.145]                     base::options(mc.cores = 1L)
[01:28:09.145]                   }
[01:28:09.145]                   options(future.plan = NULL)
[01:28:09.145]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.145]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.145]                 }
[01:28:09.145]                 ...future.workdir <- getwd()
[01:28:09.145]             }
[01:28:09.145]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.145]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.145]         }
[01:28:09.145]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.145]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:09.145]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.145]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.145]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.145]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.145]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.145]             base::names(...future.oldOptions))
[01:28:09.145]     }
[01:28:09.145]     if (FALSE) {
[01:28:09.145]     }
[01:28:09.145]     else {
[01:28:09.145]         if (TRUE) {
[01:28:09.145]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.145]                 open = "w")
[01:28:09.145]         }
[01:28:09.145]         else {
[01:28:09.145]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.145]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.145]         }
[01:28:09.145]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.145]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.145]             base::sink(type = "output", split = FALSE)
[01:28:09.145]             base::close(...future.stdout)
[01:28:09.145]         }, add = TRUE)
[01:28:09.145]     }
[01:28:09.145]     ...future.frame <- base::sys.nframe()
[01:28:09.145]     ...future.conditions <- base::list()
[01:28:09.145]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.145]     if (FALSE) {
[01:28:09.145]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.145]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.145]     }
[01:28:09.145]     ...future.result <- base::tryCatch({
[01:28:09.145]         base::withCallingHandlers({
[01:28:09.145]             ...future.value <- base::withVisible(base::local({
[01:28:09.145]                 ...future.makeSendCondition <- base::local({
[01:28:09.145]                   sendCondition <- NULL
[01:28:09.145]                   function(frame = 1L) {
[01:28:09.145]                     if (is.function(sendCondition)) 
[01:28:09.145]                       return(sendCondition)
[01:28:09.145]                     ns <- getNamespace("parallel")
[01:28:09.145]                     if (exists("sendData", mode = "function", 
[01:28:09.145]                       envir = ns)) {
[01:28:09.145]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.145]                         envir = ns)
[01:28:09.145]                       envir <- sys.frame(frame)
[01:28:09.145]                       master <- NULL
[01:28:09.145]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.145]                         !identical(envir, emptyenv())) {
[01:28:09.145]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.145]                           inherits = FALSE)) {
[01:28:09.145]                           master <- get("master", mode = "list", 
[01:28:09.145]                             envir = envir, inherits = FALSE)
[01:28:09.145]                           if (inherits(master, c("SOCKnode", 
[01:28:09.145]                             "SOCK0node"))) {
[01:28:09.145]                             sendCondition <<- function(cond) {
[01:28:09.145]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.145]                                 success = TRUE)
[01:28:09.145]                               parallel_sendData(master, data)
[01:28:09.145]                             }
[01:28:09.145]                             return(sendCondition)
[01:28:09.145]                           }
[01:28:09.145]                         }
[01:28:09.145]                         frame <- frame + 1L
[01:28:09.145]                         envir <- sys.frame(frame)
[01:28:09.145]                       }
[01:28:09.145]                     }
[01:28:09.145]                     sendCondition <<- function(cond) NULL
[01:28:09.145]                   }
[01:28:09.145]                 })
[01:28:09.145]                 withCallingHandlers({
[01:28:09.145]                   NA
[01:28:09.145]                 }, immediateCondition = function(cond) {
[01:28:09.145]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.145]                   sendCondition(cond)
[01:28:09.145]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.145]                   {
[01:28:09.145]                     inherits <- base::inherits
[01:28:09.145]                     invokeRestart <- base::invokeRestart
[01:28:09.145]                     is.null <- base::is.null
[01:28:09.145]                     muffled <- FALSE
[01:28:09.145]                     if (inherits(cond, "message")) {
[01:28:09.145]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.145]                       if (muffled) 
[01:28:09.145]                         invokeRestart("muffleMessage")
[01:28:09.145]                     }
[01:28:09.145]                     else if (inherits(cond, "warning")) {
[01:28:09.145]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.145]                       if (muffled) 
[01:28:09.145]                         invokeRestart("muffleWarning")
[01:28:09.145]                     }
[01:28:09.145]                     else if (inherits(cond, "condition")) {
[01:28:09.145]                       if (!is.null(pattern)) {
[01:28:09.145]                         computeRestarts <- base::computeRestarts
[01:28:09.145]                         grepl <- base::grepl
[01:28:09.145]                         restarts <- computeRestarts(cond)
[01:28:09.145]                         for (restart in restarts) {
[01:28:09.145]                           name <- restart$name
[01:28:09.145]                           if (is.null(name)) 
[01:28:09.145]                             next
[01:28:09.145]                           if (!grepl(pattern, name)) 
[01:28:09.145]                             next
[01:28:09.145]                           invokeRestart(restart)
[01:28:09.145]                           muffled <- TRUE
[01:28:09.145]                           break
[01:28:09.145]                         }
[01:28:09.145]                       }
[01:28:09.145]                     }
[01:28:09.145]                     invisible(muffled)
[01:28:09.145]                   }
[01:28:09.145]                   muffleCondition(cond)
[01:28:09.145]                 })
[01:28:09.145]             }))
[01:28:09.145]             future::FutureResult(value = ...future.value$value, 
[01:28:09.145]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.145]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.145]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.145]                     ...future.globalenv.names))
[01:28:09.145]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.145]         }, condition = base::local({
[01:28:09.145]             c <- base::c
[01:28:09.145]             inherits <- base::inherits
[01:28:09.145]             invokeRestart <- base::invokeRestart
[01:28:09.145]             length <- base::length
[01:28:09.145]             list <- base::list
[01:28:09.145]             seq.int <- base::seq.int
[01:28:09.145]             signalCondition <- base::signalCondition
[01:28:09.145]             sys.calls <- base::sys.calls
[01:28:09.145]             `[[` <- base::`[[`
[01:28:09.145]             `+` <- base::`+`
[01:28:09.145]             `<<-` <- base::`<<-`
[01:28:09.145]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.145]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.145]                   3L)]
[01:28:09.145]             }
[01:28:09.145]             function(cond) {
[01:28:09.145]                 is_error <- inherits(cond, "error")
[01:28:09.145]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.145]                   NULL)
[01:28:09.145]                 if (is_error) {
[01:28:09.145]                   sessionInformation <- function() {
[01:28:09.145]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.145]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.145]                       search = base::search(), system = base::Sys.info())
[01:28:09.145]                   }
[01:28:09.145]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.145]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.145]                     cond$call), session = sessionInformation(), 
[01:28:09.145]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.145]                   signalCondition(cond)
[01:28:09.145]                 }
[01:28:09.145]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.145]                 "immediateCondition"))) {
[01:28:09.145]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.145]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.145]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.145]                   if (TRUE && !signal) {
[01:28:09.145]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.145]                     {
[01:28:09.145]                       inherits <- base::inherits
[01:28:09.145]                       invokeRestart <- base::invokeRestart
[01:28:09.145]                       is.null <- base::is.null
[01:28:09.145]                       muffled <- FALSE
[01:28:09.145]                       if (inherits(cond, "message")) {
[01:28:09.145]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.145]                         if (muffled) 
[01:28:09.145]                           invokeRestart("muffleMessage")
[01:28:09.145]                       }
[01:28:09.145]                       else if (inherits(cond, "warning")) {
[01:28:09.145]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.145]                         if (muffled) 
[01:28:09.145]                           invokeRestart("muffleWarning")
[01:28:09.145]                       }
[01:28:09.145]                       else if (inherits(cond, "condition")) {
[01:28:09.145]                         if (!is.null(pattern)) {
[01:28:09.145]                           computeRestarts <- base::computeRestarts
[01:28:09.145]                           grepl <- base::grepl
[01:28:09.145]                           restarts <- computeRestarts(cond)
[01:28:09.145]                           for (restart in restarts) {
[01:28:09.145]                             name <- restart$name
[01:28:09.145]                             if (is.null(name)) 
[01:28:09.145]                               next
[01:28:09.145]                             if (!grepl(pattern, name)) 
[01:28:09.145]                               next
[01:28:09.145]                             invokeRestart(restart)
[01:28:09.145]                             muffled <- TRUE
[01:28:09.145]                             break
[01:28:09.145]                           }
[01:28:09.145]                         }
[01:28:09.145]                       }
[01:28:09.145]                       invisible(muffled)
[01:28:09.145]                     }
[01:28:09.145]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.145]                   }
[01:28:09.145]                 }
[01:28:09.145]                 else {
[01:28:09.145]                   if (TRUE) {
[01:28:09.145]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.145]                     {
[01:28:09.145]                       inherits <- base::inherits
[01:28:09.145]                       invokeRestart <- base::invokeRestart
[01:28:09.145]                       is.null <- base::is.null
[01:28:09.145]                       muffled <- FALSE
[01:28:09.145]                       if (inherits(cond, "message")) {
[01:28:09.145]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.145]                         if (muffled) 
[01:28:09.145]                           invokeRestart("muffleMessage")
[01:28:09.145]                       }
[01:28:09.145]                       else if (inherits(cond, "warning")) {
[01:28:09.145]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.145]                         if (muffled) 
[01:28:09.145]                           invokeRestart("muffleWarning")
[01:28:09.145]                       }
[01:28:09.145]                       else if (inherits(cond, "condition")) {
[01:28:09.145]                         if (!is.null(pattern)) {
[01:28:09.145]                           computeRestarts <- base::computeRestarts
[01:28:09.145]                           grepl <- base::grepl
[01:28:09.145]                           restarts <- computeRestarts(cond)
[01:28:09.145]                           for (restart in restarts) {
[01:28:09.145]                             name <- restart$name
[01:28:09.145]                             if (is.null(name)) 
[01:28:09.145]                               next
[01:28:09.145]                             if (!grepl(pattern, name)) 
[01:28:09.145]                               next
[01:28:09.145]                             invokeRestart(restart)
[01:28:09.145]                             muffled <- TRUE
[01:28:09.145]                             break
[01:28:09.145]                           }
[01:28:09.145]                         }
[01:28:09.145]                       }
[01:28:09.145]                       invisible(muffled)
[01:28:09.145]                     }
[01:28:09.145]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.145]                   }
[01:28:09.145]                 }
[01:28:09.145]             }
[01:28:09.145]         }))
[01:28:09.145]     }, error = function(ex) {
[01:28:09.145]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.145]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.145]                 ...future.rng), started = ...future.startTime, 
[01:28:09.145]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.145]             version = "1.8"), class = "FutureResult")
[01:28:09.145]     }, finally = {
[01:28:09.145]         if (!identical(...future.workdir, getwd())) 
[01:28:09.145]             setwd(...future.workdir)
[01:28:09.145]         {
[01:28:09.145]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.145]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.145]             }
[01:28:09.145]             base::options(...future.oldOptions)
[01:28:09.145]             if (.Platform$OS.type == "windows") {
[01:28:09.145]                 old_names <- names(...future.oldEnvVars)
[01:28:09.145]                 envs <- base::Sys.getenv()
[01:28:09.145]                 names <- names(envs)
[01:28:09.145]                 common <- intersect(names, old_names)
[01:28:09.145]                 added <- setdiff(names, old_names)
[01:28:09.145]                 removed <- setdiff(old_names, names)
[01:28:09.145]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.145]                   envs[common]]
[01:28:09.145]                 NAMES <- toupper(changed)
[01:28:09.145]                 args <- list()
[01:28:09.145]                 for (kk in seq_along(NAMES)) {
[01:28:09.145]                   name <- changed[[kk]]
[01:28:09.145]                   NAME <- NAMES[[kk]]
[01:28:09.145]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.145]                     next
[01:28:09.145]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.145]                 }
[01:28:09.145]                 NAMES <- toupper(added)
[01:28:09.145]                 for (kk in seq_along(NAMES)) {
[01:28:09.145]                   name <- added[[kk]]
[01:28:09.145]                   NAME <- NAMES[[kk]]
[01:28:09.145]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.145]                     next
[01:28:09.145]                   args[[name]] <- ""
[01:28:09.145]                 }
[01:28:09.145]                 NAMES <- toupper(removed)
[01:28:09.145]                 for (kk in seq_along(NAMES)) {
[01:28:09.145]                   name <- removed[[kk]]
[01:28:09.145]                   NAME <- NAMES[[kk]]
[01:28:09.145]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.145]                     next
[01:28:09.145]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.145]                 }
[01:28:09.145]                 if (length(args) > 0) 
[01:28:09.145]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.145]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.145]             }
[01:28:09.145]             else {
[01:28:09.145]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.145]             }
[01:28:09.145]             {
[01:28:09.145]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.145]                   0L) {
[01:28:09.145]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.145]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.145]                   base::options(opts)
[01:28:09.145]                 }
[01:28:09.145]                 {
[01:28:09.145]                   {
[01:28:09.145]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.145]                     NULL
[01:28:09.145]                   }
[01:28:09.145]                   options(future.plan = NULL)
[01:28:09.145]                   if (is.na(NA_character_)) 
[01:28:09.145]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.145]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.145]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.145]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.145]                     envir = parent.frame()) 
[01:28:09.145]                   {
[01:28:09.145]                     if (is.function(workers)) 
[01:28:09.145]                       workers <- workers()
[01:28:09.145]                     workers <- structure(as.integer(workers), 
[01:28:09.145]                       class = class(workers))
[01:28:09.145]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.145]                       workers >= 1)
[01:28:09.145]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.145]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.145]                     }
[01:28:09.145]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.145]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.145]                       envir = envir)
[01:28:09.145]                     if (!future$lazy) 
[01:28:09.145]                       future <- run(future)
[01:28:09.145]                     invisible(future)
[01:28:09.145]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.145]                 }
[01:28:09.145]             }
[01:28:09.145]         }
[01:28:09.145]     })
[01:28:09.145]     if (TRUE) {
[01:28:09.145]         base::sink(type = "output", split = FALSE)
[01:28:09.145]         if (TRUE) {
[01:28:09.145]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.145]         }
[01:28:09.145]         else {
[01:28:09.145]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.145]         }
[01:28:09.145]         base::close(...future.stdout)
[01:28:09.145]         ...future.stdout <- NULL
[01:28:09.145]     }
[01:28:09.145]     ...future.result$conditions <- ...future.conditions
[01:28:09.145]     ...future.result$finished <- base::Sys.time()
[01:28:09.145]     ...future.result
[01:28:09.145] }
[01:28:09.224] MultisessionFuture started
[01:28:09.225] result() for ClusterFuture ...
[01:28:09.225] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.226] - Validating connection of MultisessionFuture
[01:28:09.284] - received message: FutureResult
[01:28:09.284] - Received FutureResult
[01:28:09.288] - Erased future from FutureRegistry
[01:28:09.288] result() for ClusterFuture ...
[01:28:09.288] - result already collected: FutureResult
[01:28:09.288] result() for ClusterFuture ... done
[01:28:09.289] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.289] result() for ClusterFuture ... done
[01:28:09.289] result() for ClusterFuture ...
[01:28:09.289] - result already collected: FutureResult
[01:28:09.289] result() for ClusterFuture ... done
[01:28:09.290] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:09.293] plan(): nbrOfWorkers() = 2
Method for identifying globals: 'conservative' ...
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.293] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.294] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.296] - globals found: [3] '{', '<-', '*'
[01:28:09.296] Searching for globals ... DONE
[01:28:09.296] Resolving globals: TRUE
[01:28:09.297] Resolving any globals that are futures ...
[01:28:09.297] - globals: [3] '{', '<-', '*'
[01:28:09.297] Resolving any globals that are futures ... DONE
[01:28:09.298] 
[01:28:09.298] 
[01:28:09.298] getGlobalsAndPackages() ... DONE
[01:28:09.298] run() for 'Future' ...
[01:28:09.299] - state: 'created'
[01:28:09.299] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.314] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.315] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.315]   - Field: 'node'
[01:28:09.315]   - Field: 'label'
[01:28:09.315]   - Field: 'local'
[01:28:09.315]   - Field: 'owner'
[01:28:09.316]   - Field: 'envir'
[01:28:09.316]   - Field: 'workers'
[01:28:09.316]   - Field: 'packages'
[01:28:09.316]   - Field: 'gc'
[01:28:09.316]   - Field: 'conditions'
[01:28:09.317]   - Field: 'persistent'
[01:28:09.317]   - Field: 'expr'
[01:28:09.317]   - Field: 'uuid'
[01:28:09.317]   - Field: 'seed'
[01:28:09.317]   - Field: 'version'
[01:28:09.318]   - Field: 'result'
[01:28:09.318]   - Field: 'asynchronous'
[01:28:09.318]   - Field: 'calls'
[01:28:09.318]   - Field: 'globals'
[01:28:09.318]   - Field: 'stdout'
[01:28:09.318]   - Field: 'earlySignal'
[01:28:09.319]   - Field: 'lazy'
[01:28:09.319]   - Field: 'state'
[01:28:09.319] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.319] - Launch lazy future ...
[01:28:09.320] Packages needed by the future expression (n = 0): <none>
[01:28:09.320] Packages needed by future strategies (n = 0): <none>
[01:28:09.321] {
[01:28:09.321]     {
[01:28:09.321]         {
[01:28:09.321]             ...future.startTime <- base::Sys.time()
[01:28:09.321]             {
[01:28:09.321]                 {
[01:28:09.321]                   {
[01:28:09.321]                     {
[01:28:09.321]                       base::local({
[01:28:09.321]                         has_future <- base::requireNamespace("future", 
[01:28:09.321]                           quietly = TRUE)
[01:28:09.321]                         if (has_future) {
[01:28:09.321]                           ns <- base::getNamespace("future")
[01:28:09.321]                           version <- ns[[".package"]][["version"]]
[01:28:09.321]                           if (is.null(version)) 
[01:28:09.321]                             version <- utils::packageVersion("future")
[01:28:09.321]                         }
[01:28:09.321]                         else {
[01:28:09.321]                           version <- NULL
[01:28:09.321]                         }
[01:28:09.321]                         if (!has_future || version < "1.8.0") {
[01:28:09.321]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.321]                             "", base::R.version$version.string), 
[01:28:09.321]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.321]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.321]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.321]                               "release", "version")], collapse = " "), 
[01:28:09.321]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.321]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.321]                             info)
[01:28:09.321]                           info <- base::paste(info, collapse = "; ")
[01:28:09.321]                           if (!has_future) {
[01:28:09.321]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.321]                               info)
[01:28:09.321]                           }
[01:28:09.321]                           else {
[01:28:09.321]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.321]                               info, version)
[01:28:09.321]                           }
[01:28:09.321]                           base::stop(msg)
[01:28:09.321]                         }
[01:28:09.321]                       })
[01:28:09.321]                     }
[01:28:09.321]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.321]                     base::options(mc.cores = 1L)
[01:28:09.321]                   }
[01:28:09.321]                   options(future.plan = NULL)
[01:28:09.321]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.321]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.321]                 }
[01:28:09.321]                 ...future.workdir <- getwd()
[01:28:09.321]             }
[01:28:09.321]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.321]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.321]         }
[01:28:09.321]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.321]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.321]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.321]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.321]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.321]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.321]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.321]             base::names(...future.oldOptions))
[01:28:09.321]     }
[01:28:09.321]     if (FALSE) {
[01:28:09.321]     }
[01:28:09.321]     else {
[01:28:09.321]         if (TRUE) {
[01:28:09.321]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.321]                 open = "w")
[01:28:09.321]         }
[01:28:09.321]         else {
[01:28:09.321]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.321]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.321]         }
[01:28:09.321]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.321]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.321]             base::sink(type = "output", split = FALSE)
[01:28:09.321]             base::close(...future.stdout)
[01:28:09.321]         }, add = TRUE)
[01:28:09.321]     }
[01:28:09.321]     ...future.frame <- base::sys.nframe()
[01:28:09.321]     ...future.conditions <- base::list()
[01:28:09.321]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.321]     if (FALSE) {
[01:28:09.321]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.321]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.321]     }
[01:28:09.321]     ...future.result <- base::tryCatch({
[01:28:09.321]         base::withCallingHandlers({
[01:28:09.321]             ...future.value <- base::withVisible(base::local({
[01:28:09.321]                 ...future.makeSendCondition <- base::local({
[01:28:09.321]                   sendCondition <- NULL
[01:28:09.321]                   function(frame = 1L) {
[01:28:09.321]                     if (is.function(sendCondition)) 
[01:28:09.321]                       return(sendCondition)
[01:28:09.321]                     ns <- getNamespace("parallel")
[01:28:09.321]                     if (exists("sendData", mode = "function", 
[01:28:09.321]                       envir = ns)) {
[01:28:09.321]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.321]                         envir = ns)
[01:28:09.321]                       envir <- sys.frame(frame)
[01:28:09.321]                       master <- NULL
[01:28:09.321]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.321]                         !identical(envir, emptyenv())) {
[01:28:09.321]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.321]                           inherits = FALSE)) {
[01:28:09.321]                           master <- get("master", mode = "list", 
[01:28:09.321]                             envir = envir, inherits = FALSE)
[01:28:09.321]                           if (inherits(master, c("SOCKnode", 
[01:28:09.321]                             "SOCK0node"))) {
[01:28:09.321]                             sendCondition <<- function(cond) {
[01:28:09.321]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.321]                                 success = TRUE)
[01:28:09.321]                               parallel_sendData(master, data)
[01:28:09.321]                             }
[01:28:09.321]                             return(sendCondition)
[01:28:09.321]                           }
[01:28:09.321]                         }
[01:28:09.321]                         frame <- frame + 1L
[01:28:09.321]                         envir <- sys.frame(frame)
[01:28:09.321]                       }
[01:28:09.321]                     }
[01:28:09.321]                     sendCondition <<- function(cond) NULL
[01:28:09.321]                   }
[01:28:09.321]                 })
[01:28:09.321]                 withCallingHandlers({
[01:28:09.321]                   {
[01:28:09.321]                     b <- a
[01:28:09.321]                     a <- 2
[01:28:09.321]                     a * b
[01:28:09.321]                   }
[01:28:09.321]                 }, immediateCondition = function(cond) {
[01:28:09.321]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.321]                   sendCondition(cond)
[01:28:09.321]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.321]                   {
[01:28:09.321]                     inherits <- base::inherits
[01:28:09.321]                     invokeRestart <- base::invokeRestart
[01:28:09.321]                     is.null <- base::is.null
[01:28:09.321]                     muffled <- FALSE
[01:28:09.321]                     if (inherits(cond, "message")) {
[01:28:09.321]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.321]                       if (muffled) 
[01:28:09.321]                         invokeRestart("muffleMessage")
[01:28:09.321]                     }
[01:28:09.321]                     else if (inherits(cond, "warning")) {
[01:28:09.321]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.321]                       if (muffled) 
[01:28:09.321]                         invokeRestart("muffleWarning")
[01:28:09.321]                     }
[01:28:09.321]                     else if (inherits(cond, "condition")) {
[01:28:09.321]                       if (!is.null(pattern)) {
[01:28:09.321]                         computeRestarts <- base::computeRestarts
[01:28:09.321]                         grepl <- base::grepl
[01:28:09.321]                         restarts <- computeRestarts(cond)
[01:28:09.321]                         for (restart in restarts) {
[01:28:09.321]                           name <- restart$name
[01:28:09.321]                           if (is.null(name)) 
[01:28:09.321]                             next
[01:28:09.321]                           if (!grepl(pattern, name)) 
[01:28:09.321]                             next
[01:28:09.321]                           invokeRestart(restart)
[01:28:09.321]                           muffled <- TRUE
[01:28:09.321]                           break
[01:28:09.321]                         }
[01:28:09.321]                       }
[01:28:09.321]                     }
[01:28:09.321]                     invisible(muffled)
[01:28:09.321]                   }
[01:28:09.321]                   muffleCondition(cond)
[01:28:09.321]                 })
[01:28:09.321]             }))
[01:28:09.321]             future::FutureResult(value = ...future.value$value, 
[01:28:09.321]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.321]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.321]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.321]                     ...future.globalenv.names))
[01:28:09.321]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.321]         }, condition = base::local({
[01:28:09.321]             c <- base::c
[01:28:09.321]             inherits <- base::inherits
[01:28:09.321]             invokeRestart <- base::invokeRestart
[01:28:09.321]             length <- base::length
[01:28:09.321]             list <- base::list
[01:28:09.321]             seq.int <- base::seq.int
[01:28:09.321]             signalCondition <- base::signalCondition
[01:28:09.321]             sys.calls <- base::sys.calls
[01:28:09.321]             `[[` <- base::`[[`
[01:28:09.321]             `+` <- base::`+`
[01:28:09.321]             `<<-` <- base::`<<-`
[01:28:09.321]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.321]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.321]                   3L)]
[01:28:09.321]             }
[01:28:09.321]             function(cond) {
[01:28:09.321]                 is_error <- inherits(cond, "error")
[01:28:09.321]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.321]                   NULL)
[01:28:09.321]                 if (is_error) {
[01:28:09.321]                   sessionInformation <- function() {
[01:28:09.321]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.321]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.321]                       search = base::search(), system = base::Sys.info())
[01:28:09.321]                   }
[01:28:09.321]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.321]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.321]                     cond$call), session = sessionInformation(), 
[01:28:09.321]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.321]                   signalCondition(cond)
[01:28:09.321]                 }
[01:28:09.321]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.321]                 "immediateCondition"))) {
[01:28:09.321]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.321]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.321]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.321]                   if (TRUE && !signal) {
[01:28:09.321]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.321]                     {
[01:28:09.321]                       inherits <- base::inherits
[01:28:09.321]                       invokeRestart <- base::invokeRestart
[01:28:09.321]                       is.null <- base::is.null
[01:28:09.321]                       muffled <- FALSE
[01:28:09.321]                       if (inherits(cond, "message")) {
[01:28:09.321]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.321]                         if (muffled) 
[01:28:09.321]                           invokeRestart("muffleMessage")
[01:28:09.321]                       }
[01:28:09.321]                       else if (inherits(cond, "warning")) {
[01:28:09.321]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.321]                         if (muffled) 
[01:28:09.321]                           invokeRestart("muffleWarning")
[01:28:09.321]                       }
[01:28:09.321]                       else if (inherits(cond, "condition")) {
[01:28:09.321]                         if (!is.null(pattern)) {
[01:28:09.321]                           computeRestarts <- base::computeRestarts
[01:28:09.321]                           grepl <- base::grepl
[01:28:09.321]                           restarts <- computeRestarts(cond)
[01:28:09.321]                           for (restart in restarts) {
[01:28:09.321]                             name <- restart$name
[01:28:09.321]                             if (is.null(name)) 
[01:28:09.321]                               next
[01:28:09.321]                             if (!grepl(pattern, name)) 
[01:28:09.321]                               next
[01:28:09.321]                             invokeRestart(restart)
[01:28:09.321]                             muffled <- TRUE
[01:28:09.321]                             break
[01:28:09.321]                           }
[01:28:09.321]                         }
[01:28:09.321]                       }
[01:28:09.321]                       invisible(muffled)
[01:28:09.321]                     }
[01:28:09.321]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.321]                   }
[01:28:09.321]                 }
[01:28:09.321]                 else {
[01:28:09.321]                   if (TRUE) {
[01:28:09.321]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.321]                     {
[01:28:09.321]                       inherits <- base::inherits
[01:28:09.321]                       invokeRestart <- base::invokeRestart
[01:28:09.321]                       is.null <- base::is.null
[01:28:09.321]                       muffled <- FALSE
[01:28:09.321]                       if (inherits(cond, "message")) {
[01:28:09.321]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.321]                         if (muffled) 
[01:28:09.321]                           invokeRestart("muffleMessage")
[01:28:09.321]                       }
[01:28:09.321]                       else if (inherits(cond, "warning")) {
[01:28:09.321]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.321]                         if (muffled) 
[01:28:09.321]                           invokeRestart("muffleWarning")
[01:28:09.321]                       }
[01:28:09.321]                       else if (inherits(cond, "condition")) {
[01:28:09.321]                         if (!is.null(pattern)) {
[01:28:09.321]                           computeRestarts <- base::computeRestarts
[01:28:09.321]                           grepl <- base::grepl
[01:28:09.321]                           restarts <- computeRestarts(cond)
[01:28:09.321]                           for (restart in restarts) {
[01:28:09.321]                             name <- restart$name
[01:28:09.321]                             if (is.null(name)) 
[01:28:09.321]                               next
[01:28:09.321]                             if (!grepl(pattern, name)) 
[01:28:09.321]                               next
[01:28:09.321]                             invokeRestart(restart)
[01:28:09.321]                             muffled <- TRUE
[01:28:09.321]                             break
[01:28:09.321]                           }
[01:28:09.321]                         }
[01:28:09.321]                       }
[01:28:09.321]                       invisible(muffled)
[01:28:09.321]                     }
[01:28:09.321]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.321]                   }
[01:28:09.321]                 }
[01:28:09.321]             }
[01:28:09.321]         }))
[01:28:09.321]     }, error = function(ex) {
[01:28:09.321]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.321]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.321]                 ...future.rng), started = ...future.startTime, 
[01:28:09.321]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.321]             version = "1.8"), class = "FutureResult")
[01:28:09.321]     }, finally = {
[01:28:09.321]         if (!identical(...future.workdir, getwd())) 
[01:28:09.321]             setwd(...future.workdir)
[01:28:09.321]         {
[01:28:09.321]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.321]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.321]             }
[01:28:09.321]             base::options(...future.oldOptions)
[01:28:09.321]             if (.Platform$OS.type == "windows") {
[01:28:09.321]                 old_names <- names(...future.oldEnvVars)
[01:28:09.321]                 envs <- base::Sys.getenv()
[01:28:09.321]                 names <- names(envs)
[01:28:09.321]                 common <- intersect(names, old_names)
[01:28:09.321]                 added <- setdiff(names, old_names)
[01:28:09.321]                 removed <- setdiff(old_names, names)
[01:28:09.321]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.321]                   envs[common]]
[01:28:09.321]                 NAMES <- toupper(changed)
[01:28:09.321]                 args <- list()
[01:28:09.321]                 for (kk in seq_along(NAMES)) {
[01:28:09.321]                   name <- changed[[kk]]
[01:28:09.321]                   NAME <- NAMES[[kk]]
[01:28:09.321]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.321]                     next
[01:28:09.321]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.321]                 }
[01:28:09.321]                 NAMES <- toupper(added)
[01:28:09.321]                 for (kk in seq_along(NAMES)) {
[01:28:09.321]                   name <- added[[kk]]
[01:28:09.321]                   NAME <- NAMES[[kk]]
[01:28:09.321]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.321]                     next
[01:28:09.321]                   args[[name]] <- ""
[01:28:09.321]                 }
[01:28:09.321]                 NAMES <- toupper(removed)
[01:28:09.321]                 for (kk in seq_along(NAMES)) {
[01:28:09.321]                   name <- removed[[kk]]
[01:28:09.321]                   NAME <- NAMES[[kk]]
[01:28:09.321]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.321]                     next
[01:28:09.321]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.321]                 }
[01:28:09.321]                 if (length(args) > 0) 
[01:28:09.321]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.321]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.321]             }
[01:28:09.321]             else {
[01:28:09.321]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.321]             }
[01:28:09.321]             {
[01:28:09.321]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.321]                   0L) {
[01:28:09.321]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.321]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.321]                   base::options(opts)
[01:28:09.321]                 }
[01:28:09.321]                 {
[01:28:09.321]                   {
[01:28:09.321]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.321]                     NULL
[01:28:09.321]                   }
[01:28:09.321]                   options(future.plan = NULL)
[01:28:09.321]                   if (is.na(NA_character_)) 
[01:28:09.321]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.321]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.321]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.321]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.321]                     envir = parent.frame()) 
[01:28:09.321]                   {
[01:28:09.321]                     if (is.function(workers)) 
[01:28:09.321]                       workers <- workers()
[01:28:09.321]                     workers <- structure(as.integer(workers), 
[01:28:09.321]                       class = class(workers))
[01:28:09.321]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.321]                       workers >= 1)
[01:28:09.321]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.321]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.321]                     }
[01:28:09.321]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.321]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.321]                       envir = envir)
[01:28:09.321]                     if (!future$lazy) 
[01:28:09.321]                       future <- run(future)
[01:28:09.321]                     invisible(future)
[01:28:09.321]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.321]                 }
[01:28:09.321]             }
[01:28:09.321]         }
[01:28:09.321]     })
[01:28:09.321]     if (TRUE) {
[01:28:09.321]         base::sink(type = "output", split = FALSE)
[01:28:09.321]         if (TRUE) {
[01:28:09.321]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.321]         }
[01:28:09.321]         else {
[01:28:09.321]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.321]         }
[01:28:09.321]         base::close(...future.stdout)
[01:28:09.321]         ...future.stdout <- NULL
[01:28:09.321]     }
[01:28:09.321]     ...future.result$conditions <- ...future.conditions
[01:28:09.321]     ...future.result$finished <- base::Sys.time()
[01:28:09.321]     ...future.result
[01:28:09.321] }
[01:28:09.327] MultisessionFuture started
[01:28:09.327] - Launch lazy future ... done
[01:28:09.327] run() for 'MultisessionFuture' ... done
[01:28:09.327] result() for ClusterFuture ...
[01:28:09.328] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.328] - Validating connection of MultisessionFuture
[01:28:09.345] - received message: FutureResult
[01:28:09.346] - Received FutureResult
[01:28:09.346] - Erased future from FutureRegistry
[01:28:09.346] result() for ClusterFuture ...
[01:28:09.346] - result already collected: FutureResult
[01:28:09.346] result() for ClusterFuture ... done
[01:28:09.347] signalConditions() ...
[01:28:09.347]  - include = 'immediateCondition'
[01:28:09.347]  - exclude = 
[01:28:09.347]  - resignal = FALSE
[01:28:09.347]  - Number of conditions: 1
[01:28:09.348] signalConditions() ... done
[01:28:09.348] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.348] result() for ClusterFuture ... done
[01:28:09.348] result() for ClusterFuture ...
[01:28:09.348] - result already collected: FutureResult
[01:28:09.348] result() for ClusterFuture ... done
[01:28:09.349] signalConditions() ...
[01:28:09.349]  - include = 'immediateCondition'
[01:28:09.349]  - exclude = 
[01:28:09.349]  - resignal = FALSE
[01:28:09.349]  - Number of conditions: 1
[01:28:09.350] signalConditions() ... done
[01:28:09.350] Future state: 'finished'
[01:28:09.350] result() for ClusterFuture ...
[01:28:09.350] - result already collected: FutureResult
[01:28:09.350] result() for ClusterFuture ... done
[01:28:09.351] signalConditions() ...
[01:28:09.351]  - include = 'condition'
[01:28:09.351]  - exclude = 'immediateCondition'
[01:28:09.351]  - resignal = TRUE
[01:28:09.351]  - Number of conditions: 1
[01:28:09.352]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:09.352] signalConditions() ... done
List of 1
 $ res: 'try-error' chr "Error in eval(quote({ : object 'a' not found\n"
  ..- attr(*, "condition")=List of 3
  .. ..$ message    : chr "object 'a' not found"
  .. ..$ call       : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. ..$ future.info:List of 5
  .. .. ..$ condition:List of 2
  .. .. .. ..$ message: chr "object 'a' not found"
  .. .. .. ..$ call   : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  .. .. ..$ calls    :List of 9
  .. .. .. ..$ : language y %<-% {     b <- a ...
  .. .. .. ..$ : language futureAssignInternal(target, expr, envir = envir, substitute = FALSE)
  .. .. .. ..$ : language futureAssign(name, expr, envir = envir, assign.env = assign.env, substitute = FALSE)
  .. .. .. ..$ : language do.call(future::future, args = future.args, envir = assign.env)
  .. .. .. ..$ : language (function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE,      seed = FALSE, globals = TRUE, pack| __truncated__ ...
  .. .. .. ..$ : language Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, seed = seed,      globals = globals, packages = pack| __truncated__ ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..$ : language withCallingHandlers({     { ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. ..$ session  :List of 6
  .. .. .. ..$ r         :List of 15
  .. .. .. .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. .. .. .. ..$ arch          : chr "x86_64"
  .. .. .. .. ..$ os            : chr "mingw32"
  .. .. .. .. ..$ crt           : chr "ucrt"
  .. .. .. .. ..$ system        : chr "x86_64, mingw32"
  .. .. .. .. ..$ status        : chr "Under development (unstable)"
  .. .. .. .. ..$ major         : chr "4"
  .. .. .. .. ..$ minor         : chr "4.0"
  .. .. .. .. ..$ year          : chr "2023"
  .. .. .. .. ..$ month         : chr "12"
  .. .. .. .. ..$ day           : chr "20"
  .. .. .. .. ..$ svn rev       : chr "85713"
  .. .. .. .. ..$ language      : chr "R"
  .. .. .. .. ..$ version.string: chr "R Under development (unstable) (2023-12-20 r85713 ucrt)"
  .. .. .. .. ..$ nickname      : chr "Unsuffered Consequences"
  .. .. .. ..$ locale    : chr "LC_COLLATE=C;LC_CTYPE=German_Germany.utf8;LC_MONETARY=C;LC_NUMERIC=C;LC_TIME=C"
  .. .. .. ..$ rngkind   : chr [1:3] "Mersenne-Twister" "Inversion" "Rejection"
  .. .. .. ..$ namespaces: chr [1:16] "compiler" "parallelly" "graphics" "tools" ...
  .. .. .. ..$ search    : chr [1:9] ".GlobalEnv" "package:stats" "package:graphics" "package:grDevices" ...
  .. .. .. ..$ system    : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. .. ..$ timestamp: POSIXct[1:1], format: "2023-12-22 01:28:09"
  .. .. ..$ signaled : int 1
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.373] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.373] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.375] - globals found: [3] '{', '<-', '*'
[01:28:09.376] Searching for globals ... DONE
[01:28:09.376] Resolving globals: TRUE
[01:28:09.376] Resolving any globals that are futures ...
[01:28:09.376] - globals: [3] '{', '<-', '*'
[01:28:09.376] Resolving any globals that are futures ... DONE
[01:28:09.377] 
[01:28:09.377] 
[01:28:09.377] getGlobalsAndPackages() ... DONE
[01:28:09.378] run() for 'Future' ...
[01:28:09.378] - state: 'created'
[01:28:09.378] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.393] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.394] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.394]   - Field: 'node'
[01:28:09.394]   - Field: 'label'
[01:28:09.394]   - Field: 'local'
[01:28:09.394]   - Field: 'owner'
[01:28:09.395]   - Field: 'envir'
[01:28:09.395]   - Field: 'workers'
[01:28:09.395]   - Field: 'packages'
[01:28:09.395]   - Field: 'gc'
[01:28:09.395]   - Field: 'conditions'
[01:28:09.396]   - Field: 'persistent'
[01:28:09.396]   - Field: 'expr'
[01:28:09.396]   - Field: 'uuid'
[01:28:09.396]   - Field: 'seed'
[01:28:09.396]   - Field: 'version'
[01:28:09.397]   - Field: 'result'
[01:28:09.397]   - Field: 'asynchronous'
[01:28:09.397]   - Field: 'calls'
[01:28:09.397]   - Field: 'globals'
[01:28:09.397]   - Field: 'stdout'
[01:28:09.398]   - Field: 'earlySignal'
[01:28:09.398]   - Field: 'lazy'
[01:28:09.401]   - Field: 'state'
[01:28:09.401] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.401] - Launch lazy future ...
[01:28:09.401] Packages needed by the future expression (n = 0): <none>
[01:28:09.402] Packages needed by future strategies (n = 0): <none>
[01:28:09.402] {
[01:28:09.402]     {
[01:28:09.402]         {
[01:28:09.402]             ...future.startTime <- base::Sys.time()
[01:28:09.402]             {
[01:28:09.402]                 {
[01:28:09.402]                   {
[01:28:09.402]                     {
[01:28:09.402]                       base::local({
[01:28:09.402]                         has_future <- base::requireNamespace("future", 
[01:28:09.402]                           quietly = TRUE)
[01:28:09.402]                         if (has_future) {
[01:28:09.402]                           ns <- base::getNamespace("future")
[01:28:09.402]                           version <- ns[[".package"]][["version"]]
[01:28:09.402]                           if (is.null(version)) 
[01:28:09.402]                             version <- utils::packageVersion("future")
[01:28:09.402]                         }
[01:28:09.402]                         else {
[01:28:09.402]                           version <- NULL
[01:28:09.402]                         }
[01:28:09.402]                         if (!has_future || version < "1.8.0") {
[01:28:09.402]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.402]                             "", base::R.version$version.string), 
[01:28:09.402]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.402]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.402]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.402]                               "release", "version")], collapse = " "), 
[01:28:09.402]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.402]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.402]                             info)
[01:28:09.402]                           info <- base::paste(info, collapse = "; ")
[01:28:09.402]                           if (!has_future) {
[01:28:09.402]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.402]                               info)
[01:28:09.402]                           }
[01:28:09.402]                           else {
[01:28:09.402]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.402]                               info, version)
[01:28:09.402]                           }
[01:28:09.402]                           base::stop(msg)
[01:28:09.402]                         }
[01:28:09.402]                       })
[01:28:09.402]                     }
[01:28:09.402]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.402]                     base::options(mc.cores = 1L)
[01:28:09.402]                   }
[01:28:09.402]                   options(future.plan = NULL)
[01:28:09.402]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.402]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.402]                 }
[01:28:09.402]                 ...future.workdir <- getwd()
[01:28:09.402]             }
[01:28:09.402]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.402]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.402]         }
[01:28:09.402]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.402]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.402]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.402]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.402]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.402]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.402]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.402]             base::names(...future.oldOptions))
[01:28:09.402]     }
[01:28:09.402]     if (FALSE) {
[01:28:09.402]     }
[01:28:09.402]     else {
[01:28:09.402]         if (TRUE) {
[01:28:09.402]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.402]                 open = "w")
[01:28:09.402]         }
[01:28:09.402]         else {
[01:28:09.402]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.402]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.402]         }
[01:28:09.402]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.402]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.402]             base::sink(type = "output", split = FALSE)
[01:28:09.402]             base::close(...future.stdout)
[01:28:09.402]         }, add = TRUE)
[01:28:09.402]     }
[01:28:09.402]     ...future.frame <- base::sys.nframe()
[01:28:09.402]     ...future.conditions <- base::list()
[01:28:09.402]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.402]     if (FALSE) {
[01:28:09.402]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.402]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.402]     }
[01:28:09.402]     ...future.result <- base::tryCatch({
[01:28:09.402]         base::withCallingHandlers({
[01:28:09.402]             ...future.value <- base::withVisible(base::local({
[01:28:09.402]                 ...future.makeSendCondition <- base::local({
[01:28:09.402]                   sendCondition <- NULL
[01:28:09.402]                   function(frame = 1L) {
[01:28:09.402]                     if (is.function(sendCondition)) 
[01:28:09.402]                       return(sendCondition)
[01:28:09.402]                     ns <- getNamespace("parallel")
[01:28:09.402]                     if (exists("sendData", mode = "function", 
[01:28:09.402]                       envir = ns)) {
[01:28:09.402]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.402]                         envir = ns)
[01:28:09.402]                       envir <- sys.frame(frame)
[01:28:09.402]                       master <- NULL
[01:28:09.402]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.402]                         !identical(envir, emptyenv())) {
[01:28:09.402]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.402]                           inherits = FALSE)) {
[01:28:09.402]                           master <- get("master", mode = "list", 
[01:28:09.402]                             envir = envir, inherits = FALSE)
[01:28:09.402]                           if (inherits(master, c("SOCKnode", 
[01:28:09.402]                             "SOCK0node"))) {
[01:28:09.402]                             sendCondition <<- function(cond) {
[01:28:09.402]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.402]                                 success = TRUE)
[01:28:09.402]                               parallel_sendData(master, data)
[01:28:09.402]                             }
[01:28:09.402]                             return(sendCondition)
[01:28:09.402]                           }
[01:28:09.402]                         }
[01:28:09.402]                         frame <- frame + 1L
[01:28:09.402]                         envir <- sys.frame(frame)
[01:28:09.402]                       }
[01:28:09.402]                     }
[01:28:09.402]                     sendCondition <<- function(cond) NULL
[01:28:09.402]                   }
[01:28:09.402]                 })
[01:28:09.402]                 withCallingHandlers({
[01:28:09.402]                   {
[01:28:09.402]                     b <- a
[01:28:09.402]                     a <- 2
[01:28:09.402]                     a * b
[01:28:09.402]                   }
[01:28:09.402]                 }, immediateCondition = function(cond) {
[01:28:09.402]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.402]                   sendCondition(cond)
[01:28:09.402]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.402]                   {
[01:28:09.402]                     inherits <- base::inherits
[01:28:09.402]                     invokeRestart <- base::invokeRestart
[01:28:09.402]                     is.null <- base::is.null
[01:28:09.402]                     muffled <- FALSE
[01:28:09.402]                     if (inherits(cond, "message")) {
[01:28:09.402]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.402]                       if (muffled) 
[01:28:09.402]                         invokeRestart("muffleMessage")
[01:28:09.402]                     }
[01:28:09.402]                     else if (inherits(cond, "warning")) {
[01:28:09.402]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.402]                       if (muffled) 
[01:28:09.402]                         invokeRestart("muffleWarning")
[01:28:09.402]                     }
[01:28:09.402]                     else if (inherits(cond, "condition")) {
[01:28:09.402]                       if (!is.null(pattern)) {
[01:28:09.402]                         computeRestarts <- base::computeRestarts
[01:28:09.402]                         grepl <- base::grepl
[01:28:09.402]                         restarts <- computeRestarts(cond)
[01:28:09.402]                         for (restart in restarts) {
[01:28:09.402]                           name <- restart$name
[01:28:09.402]                           if (is.null(name)) 
[01:28:09.402]                             next
[01:28:09.402]                           if (!grepl(pattern, name)) 
[01:28:09.402]                             next
[01:28:09.402]                           invokeRestart(restart)
[01:28:09.402]                           muffled <- TRUE
[01:28:09.402]                           break
[01:28:09.402]                         }
[01:28:09.402]                       }
[01:28:09.402]                     }
[01:28:09.402]                     invisible(muffled)
[01:28:09.402]                   }
[01:28:09.402]                   muffleCondition(cond)
[01:28:09.402]                 })
[01:28:09.402]             }))
[01:28:09.402]             future::FutureResult(value = ...future.value$value, 
[01:28:09.402]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.402]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.402]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.402]                     ...future.globalenv.names))
[01:28:09.402]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.402]         }, condition = base::local({
[01:28:09.402]             c <- base::c
[01:28:09.402]             inherits <- base::inherits
[01:28:09.402]             invokeRestart <- base::invokeRestart
[01:28:09.402]             length <- base::length
[01:28:09.402]             list <- base::list
[01:28:09.402]             seq.int <- base::seq.int
[01:28:09.402]             signalCondition <- base::signalCondition
[01:28:09.402]             sys.calls <- base::sys.calls
[01:28:09.402]             `[[` <- base::`[[`
[01:28:09.402]             `+` <- base::`+`
[01:28:09.402]             `<<-` <- base::`<<-`
[01:28:09.402]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.402]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.402]                   3L)]
[01:28:09.402]             }
[01:28:09.402]             function(cond) {
[01:28:09.402]                 is_error <- inherits(cond, "error")
[01:28:09.402]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.402]                   NULL)
[01:28:09.402]                 if (is_error) {
[01:28:09.402]                   sessionInformation <- function() {
[01:28:09.402]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.402]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.402]                       search = base::search(), system = base::Sys.info())
[01:28:09.402]                   }
[01:28:09.402]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.402]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.402]                     cond$call), session = sessionInformation(), 
[01:28:09.402]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.402]                   signalCondition(cond)
[01:28:09.402]                 }
[01:28:09.402]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.402]                 "immediateCondition"))) {
[01:28:09.402]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.402]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.402]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.402]                   if (TRUE && !signal) {
[01:28:09.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.402]                     {
[01:28:09.402]                       inherits <- base::inherits
[01:28:09.402]                       invokeRestart <- base::invokeRestart
[01:28:09.402]                       is.null <- base::is.null
[01:28:09.402]                       muffled <- FALSE
[01:28:09.402]                       if (inherits(cond, "message")) {
[01:28:09.402]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.402]                         if (muffled) 
[01:28:09.402]                           invokeRestart("muffleMessage")
[01:28:09.402]                       }
[01:28:09.402]                       else if (inherits(cond, "warning")) {
[01:28:09.402]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.402]                         if (muffled) 
[01:28:09.402]                           invokeRestart("muffleWarning")
[01:28:09.402]                       }
[01:28:09.402]                       else if (inherits(cond, "condition")) {
[01:28:09.402]                         if (!is.null(pattern)) {
[01:28:09.402]                           computeRestarts <- base::computeRestarts
[01:28:09.402]                           grepl <- base::grepl
[01:28:09.402]                           restarts <- computeRestarts(cond)
[01:28:09.402]                           for (restart in restarts) {
[01:28:09.402]                             name <- restart$name
[01:28:09.402]                             if (is.null(name)) 
[01:28:09.402]                               next
[01:28:09.402]                             if (!grepl(pattern, name)) 
[01:28:09.402]                               next
[01:28:09.402]                             invokeRestart(restart)
[01:28:09.402]                             muffled <- TRUE
[01:28:09.402]                             break
[01:28:09.402]                           }
[01:28:09.402]                         }
[01:28:09.402]                       }
[01:28:09.402]                       invisible(muffled)
[01:28:09.402]                     }
[01:28:09.402]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.402]                   }
[01:28:09.402]                 }
[01:28:09.402]                 else {
[01:28:09.402]                   if (TRUE) {
[01:28:09.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.402]                     {
[01:28:09.402]                       inherits <- base::inherits
[01:28:09.402]                       invokeRestart <- base::invokeRestart
[01:28:09.402]                       is.null <- base::is.null
[01:28:09.402]                       muffled <- FALSE
[01:28:09.402]                       if (inherits(cond, "message")) {
[01:28:09.402]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.402]                         if (muffled) 
[01:28:09.402]                           invokeRestart("muffleMessage")
[01:28:09.402]                       }
[01:28:09.402]                       else if (inherits(cond, "warning")) {
[01:28:09.402]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.402]                         if (muffled) 
[01:28:09.402]                           invokeRestart("muffleWarning")
[01:28:09.402]                       }
[01:28:09.402]                       else if (inherits(cond, "condition")) {
[01:28:09.402]                         if (!is.null(pattern)) {
[01:28:09.402]                           computeRestarts <- base::computeRestarts
[01:28:09.402]                           grepl <- base::grepl
[01:28:09.402]                           restarts <- computeRestarts(cond)
[01:28:09.402]                           for (restart in restarts) {
[01:28:09.402]                             name <- restart$name
[01:28:09.402]                             if (is.null(name)) 
[01:28:09.402]                               next
[01:28:09.402]                             if (!grepl(pattern, name)) 
[01:28:09.402]                               next
[01:28:09.402]                             invokeRestart(restart)
[01:28:09.402]                             muffled <- TRUE
[01:28:09.402]                             break
[01:28:09.402]                           }
[01:28:09.402]                         }
[01:28:09.402]                       }
[01:28:09.402]                       invisible(muffled)
[01:28:09.402]                     }
[01:28:09.402]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.402]                   }
[01:28:09.402]                 }
[01:28:09.402]             }
[01:28:09.402]         }))
[01:28:09.402]     }, error = function(ex) {
[01:28:09.402]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.402]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.402]                 ...future.rng), started = ...future.startTime, 
[01:28:09.402]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.402]             version = "1.8"), class = "FutureResult")
[01:28:09.402]     }, finally = {
[01:28:09.402]         if (!identical(...future.workdir, getwd())) 
[01:28:09.402]             setwd(...future.workdir)
[01:28:09.402]         {
[01:28:09.402]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.402]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.402]             }
[01:28:09.402]             base::options(...future.oldOptions)
[01:28:09.402]             if (.Platform$OS.type == "windows") {
[01:28:09.402]                 old_names <- names(...future.oldEnvVars)
[01:28:09.402]                 envs <- base::Sys.getenv()
[01:28:09.402]                 names <- names(envs)
[01:28:09.402]                 common <- intersect(names, old_names)
[01:28:09.402]                 added <- setdiff(names, old_names)
[01:28:09.402]                 removed <- setdiff(old_names, names)
[01:28:09.402]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.402]                   envs[common]]
[01:28:09.402]                 NAMES <- toupper(changed)
[01:28:09.402]                 args <- list()
[01:28:09.402]                 for (kk in seq_along(NAMES)) {
[01:28:09.402]                   name <- changed[[kk]]
[01:28:09.402]                   NAME <- NAMES[[kk]]
[01:28:09.402]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.402]                     next
[01:28:09.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.402]                 }
[01:28:09.402]                 NAMES <- toupper(added)
[01:28:09.402]                 for (kk in seq_along(NAMES)) {
[01:28:09.402]                   name <- added[[kk]]
[01:28:09.402]                   NAME <- NAMES[[kk]]
[01:28:09.402]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.402]                     next
[01:28:09.402]                   args[[name]] <- ""
[01:28:09.402]                 }
[01:28:09.402]                 NAMES <- toupper(removed)
[01:28:09.402]                 for (kk in seq_along(NAMES)) {
[01:28:09.402]                   name <- removed[[kk]]
[01:28:09.402]                   NAME <- NAMES[[kk]]
[01:28:09.402]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.402]                     next
[01:28:09.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.402]                 }
[01:28:09.402]                 if (length(args) > 0) 
[01:28:09.402]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.402]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.402]             }
[01:28:09.402]             else {
[01:28:09.402]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.402]             }
[01:28:09.402]             {
[01:28:09.402]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.402]                   0L) {
[01:28:09.402]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.402]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.402]                   base::options(opts)
[01:28:09.402]                 }
[01:28:09.402]                 {
[01:28:09.402]                   {
[01:28:09.402]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.402]                     NULL
[01:28:09.402]                   }
[01:28:09.402]                   options(future.plan = NULL)
[01:28:09.402]                   if (is.na(NA_character_)) 
[01:28:09.402]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.402]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.402]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.402]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.402]                     envir = parent.frame()) 
[01:28:09.402]                   {
[01:28:09.402]                     if (is.function(workers)) 
[01:28:09.402]                       workers <- workers()
[01:28:09.402]                     workers <- structure(as.integer(workers), 
[01:28:09.402]                       class = class(workers))
[01:28:09.402]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.402]                       workers >= 1)
[01:28:09.402]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.402]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.402]                     }
[01:28:09.402]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.402]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.402]                       envir = envir)
[01:28:09.402]                     if (!future$lazy) 
[01:28:09.402]                       future <- run(future)
[01:28:09.402]                     invisible(future)
[01:28:09.402]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.402]                 }
[01:28:09.402]             }
[01:28:09.402]         }
[01:28:09.402]     })
[01:28:09.402]     if (TRUE) {
[01:28:09.402]         base::sink(type = "output", split = FALSE)
[01:28:09.402]         if (TRUE) {
[01:28:09.402]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.402]         }
[01:28:09.402]         else {
[01:28:09.402]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.402]         }
[01:28:09.402]         base::close(...future.stdout)
[01:28:09.402]         ...future.stdout <- NULL
[01:28:09.402]     }
[01:28:09.402]     ...future.result$conditions <- ...future.conditions
[01:28:09.402]     ...future.result$finished <- base::Sys.time()
[01:28:09.402]     ...future.result
[01:28:09.402] }
[01:28:09.408] MultisessionFuture started
[01:28:09.408] - Launch lazy future ... done
[01:28:09.408] run() for 'MultisessionFuture' ... done
[01:28:09.409] result() for ClusterFuture ...
[01:28:09.409] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.409] - Validating connection of MultisessionFuture
[01:28:09.427] - received message: FutureResult
[01:28:09.428] - Received FutureResult
[01:28:09.428] - Erased future from FutureRegistry
[01:28:09.428] result() for ClusterFuture ...
[01:28:09.428] - result already collected: FutureResult
[01:28:09.428] result() for ClusterFuture ... done
[01:28:09.428] signalConditions() ...
[01:28:09.429]  - include = 'immediateCondition'
[01:28:09.429]  - exclude = 
[01:28:09.429]  - resignal = FALSE
[01:28:09.429]  - Number of conditions: 1
[01:28:09.429] signalConditions() ... done
[01:28:09.429] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.430] result() for ClusterFuture ... done
[01:28:09.430] result() for ClusterFuture ...
[01:28:09.430] - result already collected: FutureResult
[01:28:09.430] result() for ClusterFuture ... done
[01:28:09.430] signalConditions() ...
[01:28:09.430]  - include = 'immediateCondition'
[01:28:09.431]  - exclude = 
[01:28:09.431]  - resignal = FALSE
[01:28:09.431]  - Number of conditions: 1
[01:28:09.431] signalConditions() ... done
[01:28:09.431] Future state: 'finished'
[01:28:09.431] result() for ClusterFuture ...
[01:28:09.432] - result already collected: FutureResult
[01:28:09.432] result() for ClusterFuture ... done
[01:28:09.432] signalConditions() ...
[01:28:09.432]  - include = 'condition'
[01:28:09.433]  - exclude = 'immediateCondition'
[01:28:09.433]  - resignal = TRUE
[01:28:09.433]  - Number of conditions: 1
[01:28:09.433]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:09.434] signalConditions() ... done
List of 1
 $ res: 'try-error' chr "Error in eval(quote({ : object 'a' not found\n"
  ..- attr(*, "condition")=List of 3
  .. ..$ message    : chr "object 'a' not found"
  .. ..$ call       : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. ..$ future.info:List of 5
  .. .. ..$ condition:List of 2
  .. .. .. ..$ message: chr "object 'a' not found"
  .. .. .. ..$ call   : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  .. .. ..$ calls    :List of 12
  .. .. .. ..$ : language y %<-% {     b <- a ...
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language y %<-% {     b <- a ...
  .. .. .. ..$ : language futureAssignInternal(target, expr, envir = envir, substitute = FALSE)
  .. .. .. ..$ : language futureAssign(name, expr, envir = envir, assign.env = assign.env, substitute = FALSE)
  .. .. .. ..$ : language do.call(future::future, args = future.args, envir = assign.env)
  .. .. .. ..$ : language (function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE,      seed = FALSE, globals = TRUE, pack| __truncated__ ...
  .. .. .. ..$ : language Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, seed = seed,      globals = globals, packages = pack| __truncated__ ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..$ : language withCallingHandlers({     { ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. ..$ session  :List of 6
  .. .. .. ..$ r         :List of 15
  .. .. .. .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. .. .. .. ..$ arch          : chr "x86_64"
  .. .. .. .. ..$ os            : chr "mingw32"
  .. .. .. .. ..$ crt           : chr "ucrt"
  .. .. .. .. ..$ system        : chr "x86_64, mingw32"
  .. .. .. .. ..$ status        : chr "Under development (unstable)"
  .. .. .. .. ..$ major         : chr "4"
  .. .. .. .. ..$ minor         : chr "4.0"
  .. .. .. .. ..$ year          : chr "2023"
  .. .. .. .. ..$ month         : chr "12"
  .. .. .. .. ..$ day           : chr "20"
  .. .. .. .. ..$ svn rev       : chr "85713"
  .. .. .. .. ..$ language      : chr "R"
  .. .. .. .. ..$ version.string: chr "R Under development (unstable) (2023-12-20 r85713 ucrt)"
  .. .. .. .. ..$ nickname      : chr "Unsuffered Consequences"
  .. .. .. ..$ locale    : chr "LC_COLLATE=C;LC_CTYPE=German_Germany.utf8;LC_MONETARY=C;LC_NUMERIC=C;LC_TIME=C"
  .. .. .. ..$ rngkind   : chr [1:3] "Mersenne-Twister" "Inversion" "Rejection"
  .. .. .. ..$ namespaces: chr [1:16] "compiler" "parallelly" "graphics" "tools" ...
  .. .. .. ..$ search    : chr [1:9] ".GlobalEnv" "package:stats" "package:graphics" "package:grDevices" ...
  .. .. .. ..$ system    : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. .. ..$ timestamp: POSIXct[1:1], format: "2023-12-22 01:28:09"
  .. .. ..$ signaled : int 1
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.452] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.452] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.454] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:09.454] Searching for globals ... DONE
[01:28:09.455] Resolving globals: TRUE
[01:28:09.455] Resolving any globals that are futures ...
[01:28:09.455] - globals: [4] '{', '<-', '*', 'ii'
[01:28:09.455] Resolving any globals that are futures ... DONE
[01:28:09.456] Resolving futures part of globals (recursively) ...
[01:28:09.456] resolve() on list ...
[01:28:09.456]  recursive: 99
[01:28:09.456]  length: 1
[01:28:09.457]  elements: 'ii'
[01:28:09.457]  length: 0 (resolved future 1)
[01:28:09.457] resolve() on list ... DONE
[01:28:09.457] - globals: [1] 'ii'
[01:28:09.457] Resolving futures part of globals (recursively) ... DONE
[01:28:09.457] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:09.458] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:09.458] - globals: [1] 'ii'
[01:28:09.458] 
[01:28:09.458] getGlobalsAndPackages() ... DONE
[01:28:09.459] run() for 'Future' ...
[01:28:09.459] - state: 'created'
[01:28:09.459] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.474] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.474] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.475]   - Field: 'node'
[01:28:09.475]   - Field: 'label'
[01:28:09.475]   - Field: 'local'
[01:28:09.475]   - Field: 'owner'
[01:28:09.475]   - Field: 'envir'
[01:28:09.475]   - Field: 'workers'
[01:28:09.476]   - Field: 'packages'
[01:28:09.476]   - Field: 'gc'
[01:28:09.476]   - Field: 'conditions'
[01:28:09.476]   - Field: 'persistent'
[01:28:09.476]   - Field: 'expr'
[01:28:09.477]   - Field: 'uuid'
[01:28:09.477]   - Field: 'seed'
[01:28:09.477]   - Field: 'version'
[01:28:09.477]   - Field: 'result'
[01:28:09.477]   - Field: 'asynchronous'
[01:28:09.477]   - Field: 'calls'
[01:28:09.478]   - Field: 'globals'
[01:28:09.478]   - Field: 'stdout'
[01:28:09.478]   - Field: 'earlySignal'
[01:28:09.478]   - Field: 'lazy'
[01:28:09.478]   - Field: 'state'
[01:28:09.478] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.479] - Launch lazy future ...
[01:28:09.479] Packages needed by the future expression (n = 0): <none>
[01:28:09.479] Packages needed by future strategies (n = 0): <none>
[01:28:09.480] {
[01:28:09.480]     {
[01:28:09.480]         {
[01:28:09.480]             ...future.startTime <- base::Sys.time()
[01:28:09.480]             {
[01:28:09.480]                 {
[01:28:09.480]                   {
[01:28:09.480]                     {
[01:28:09.480]                       base::local({
[01:28:09.480]                         has_future <- base::requireNamespace("future", 
[01:28:09.480]                           quietly = TRUE)
[01:28:09.480]                         if (has_future) {
[01:28:09.480]                           ns <- base::getNamespace("future")
[01:28:09.480]                           version <- ns[[".package"]][["version"]]
[01:28:09.480]                           if (is.null(version)) 
[01:28:09.480]                             version <- utils::packageVersion("future")
[01:28:09.480]                         }
[01:28:09.480]                         else {
[01:28:09.480]                           version <- NULL
[01:28:09.480]                         }
[01:28:09.480]                         if (!has_future || version < "1.8.0") {
[01:28:09.480]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.480]                             "", base::R.version$version.string), 
[01:28:09.480]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.480]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.480]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.480]                               "release", "version")], collapse = " "), 
[01:28:09.480]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.480]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.480]                             info)
[01:28:09.480]                           info <- base::paste(info, collapse = "; ")
[01:28:09.480]                           if (!has_future) {
[01:28:09.480]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.480]                               info)
[01:28:09.480]                           }
[01:28:09.480]                           else {
[01:28:09.480]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.480]                               info, version)
[01:28:09.480]                           }
[01:28:09.480]                           base::stop(msg)
[01:28:09.480]                         }
[01:28:09.480]                       })
[01:28:09.480]                     }
[01:28:09.480]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.480]                     base::options(mc.cores = 1L)
[01:28:09.480]                   }
[01:28:09.480]                   options(future.plan = NULL)
[01:28:09.480]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.480]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.480]                 }
[01:28:09.480]                 ...future.workdir <- getwd()
[01:28:09.480]             }
[01:28:09.480]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.480]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.480]         }
[01:28:09.480]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.480]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.480]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.480]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.480]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.480]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.480]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.480]             base::names(...future.oldOptions))
[01:28:09.480]     }
[01:28:09.480]     if (FALSE) {
[01:28:09.480]     }
[01:28:09.480]     else {
[01:28:09.480]         if (TRUE) {
[01:28:09.480]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.480]                 open = "w")
[01:28:09.480]         }
[01:28:09.480]         else {
[01:28:09.480]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.480]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.480]         }
[01:28:09.480]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.480]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.480]             base::sink(type = "output", split = FALSE)
[01:28:09.480]             base::close(...future.stdout)
[01:28:09.480]         }, add = TRUE)
[01:28:09.480]     }
[01:28:09.480]     ...future.frame <- base::sys.nframe()
[01:28:09.480]     ...future.conditions <- base::list()
[01:28:09.480]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.480]     if (FALSE) {
[01:28:09.480]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.480]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.480]     }
[01:28:09.480]     ...future.result <- base::tryCatch({
[01:28:09.480]         base::withCallingHandlers({
[01:28:09.480]             ...future.value <- base::withVisible(base::local({
[01:28:09.480]                 ...future.makeSendCondition <- base::local({
[01:28:09.480]                   sendCondition <- NULL
[01:28:09.480]                   function(frame = 1L) {
[01:28:09.480]                     if (is.function(sendCondition)) 
[01:28:09.480]                       return(sendCondition)
[01:28:09.480]                     ns <- getNamespace("parallel")
[01:28:09.480]                     if (exists("sendData", mode = "function", 
[01:28:09.480]                       envir = ns)) {
[01:28:09.480]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.480]                         envir = ns)
[01:28:09.480]                       envir <- sys.frame(frame)
[01:28:09.480]                       master <- NULL
[01:28:09.480]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.480]                         !identical(envir, emptyenv())) {
[01:28:09.480]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.480]                           inherits = FALSE)) {
[01:28:09.480]                           master <- get("master", mode = "list", 
[01:28:09.480]                             envir = envir, inherits = FALSE)
[01:28:09.480]                           if (inherits(master, c("SOCKnode", 
[01:28:09.480]                             "SOCK0node"))) {
[01:28:09.480]                             sendCondition <<- function(cond) {
[01:28:09.480]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.480]                                 success = TRUE)
[01:28:09.480]                               parallel_sendData(master, data)
[01:28:09.480]                             }
[01:28:09.480]                             return(sendCondition)
[01:28:09.480]                           }
[01:28:09.480]                         }
[01:28:09.480]                         frame <- frame + 1L
[01:28:09.480]                         envir <- sys.frame(frame)
[01:28:09.480]                       }
[01:28:09.480]                     }
[01:28:09.480]                     sendCondition <<- function(cond) NULL
[01:28:09.480]                   }
[01:28:09.480]                 })
[01:28:09.480]                 withCallingHandlers({
[01:28:09.480]                   {
[01:28:09.480]                     b <- a * ii
[01:28:09.480]                     a <- 0
[01:28:09.480]                     b
[01:28:09.480]                   }
[01:28:09.480]                 }, immediateCondition = function(cond) {
[01:28:09.480]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.480]                   sendCondition(cond)
[01:28:09.480]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.480]                   {
[01:28:09.480]                     inherits <- base::inherits
[01:28:09.480]                     invokeRestart <- base::invokeRestart
[01:28:09.480]                     is.null <- base::is.null
[01:28:09.480]                     muffled <- FALSE
[01:28:09.480]                     if (inherits(cond, "message")) {
[01:28:09.480]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.480]                       if (muffled) 
[01:28:09.480]                         invokeRestart("muffleMessage")
[01:28:09.480]                     }
[01:28:09.480]                     else if (inherits(cond, "warning")) {
[01:28:09.480]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.480]                       if (muffled) 
[01:28:09.480]                         invokeRestart("muffleWarning")
[01:28:09.480]                     }
[01:28:09.480]                     else if (inherits(cond, "condition")) {
[01:28:09.480]                       if (!is.null(pattern)) {
[01:28:09.480]                         computeRestarts <- base::computeRestarts
[01:28:09.480]                         grepl <- base::grepl
[01:28:09.480]                         restarts <- computeRestarts(cond)
[01:28:09.480]                         for (restart in restarts) {
[01:28:09.480]                           name <- restart$name
[01:28:09.480]                           if (is.null(name)) 
[01:28:09.480]                             next
[01:28:09.480]                           if (!grepl(pattern, name)) 
[01:28:09.480]                             next
[01:28:09.480]                           invokeRestart(restart)
[01:28:09.480]                           muffled <- TRUE
[01:28:09.480]                           break
[01:28:09.480]                         }
[01:28:09.480]                       }
[01:28:09.480]                     }
[01:28:09.480]                     invisible(muffled)
[01:28:09.480]                   }
[01:28:09.480]                   muffleCondition(cond)
[01:28:09.480]                 })
[01:28:09.480]             }))
[01:28:09.480]             future::FutureResult(value = ...future.value$value, 
[01:28:09.480]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.480]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.480]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.480]                     ...future.globalenv.names))
[01:28:09.480]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.480]         }, condition = base::local({
[01:28:09.480]             c <- base::c
[01:28:09.480]             inherits <- base::inherits
[01:28:09.480]             invokeRestart <- base::invokeRestart
[01:28:09.480]             length <- base::length
[01:28:09.480]             list <- base::list
[01:28:09.480]             seq.int <- base::seq.int
[01:28:09.480]             signalCondition <- base::signalCondition
[01:28:09.480]             sys.calls <- base::sys.calls
[01:28:09.480]             `[[` <- base::`[[`
[01:28:09.480]             `+` <- base::`+`
[01:28:09.480]             `<<-` <- base::`<<-`
[01:28:09.480]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.480]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.480]                   3L)]
[01:28:09.480]             }
[01:28:09.480]             function(cond) {
[01:28:09.480]                 is_error <- inherits(cond, "error")
[01:28:09.480]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.480]                   NULL)
[01:28:09.480]                 if (is_error) {
[01:28:09.480]                   sessionInformation <- function() {
[01:28:09.480]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.480]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.480]                       search = base::search(), system = base::Sys.info())
[01:28:09.480]                   }
[01:28:09.480]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.480]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.480]                     cond$call), session = sessionInformation(), 
[01:28:09.480]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.480]                   signalCondition(cond)
[01:28:09.480]                 }
[01:28:09.480]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.480]                 "immediateCondition"))) {
[01:28:09.480]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.480]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.480]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.480]                   if (TRUE && !signal) {
[01:28:09.480]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.480]                     {
[01:28:09.480]                       inherits <- base::inherits
[01:28:09.480]                       invokeRestart <- base::invokeRestart
[01:28:09.480]                       is.null <- base::is.null
[01:28:09.480]                       muffled <- FALSE
[01:28:09.480]                       if (inherits(cond, "message")) {
[01:28:09.480]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.480]                         if (muffled) 
[01:28:09.480]                           invokeRestart("muffleMessage")
[01:28:09.480]                       }
[01:28:09.480]                       else if (inherits(cond, "warning")) {
[01:28:09.480]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.480]                         if (muffled) 
[01:28:09.480]                           invokeRestart("muffleWarning")
[01:28:09.480]                       }
[01:28:09.480]                       else if (inherits(cond, "condition")) {
[01:28:09.480]                         if (!is.null(pattern)) {
[01:28:09.480]                           computeRestarts <- base::computeRestarts
[01:28:09.480]                           grepl <- base::grepl
[01:28:09.480]                           restarts <- computeRestarts(cond)
[01:28:09.480]                           for (restart in restarts) {
[01:28:09.480]                             name <- restart$name
[01:28:09.480]                             if (is.null(name)) 
[01:28:09.480]                               next
[01:28:09.480]                             if (!grepl(pattern, name)) 
[01:28:09.480]                               next
[01:28:09.480]                             invokeRestart(restart)
[01:28:09.480]                             muffled <- TRUE
[01:28:09.480]                             break
[01:28:09.480]                           }
[01:28:09.480]                         }
[01:28:09.480]                       }
[01:28:09.480]                       invisible(muffled)
[01:28:09.480]                     }
[01:28:09.480]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.480]                   }
[01:28:09.480]                 }
[01:28:09.480]                 else {
[01:28:09.480]                   if (TRUE) {
[01:28:09.480]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.480]                     {
[01:28:09.480]                       inherits <- base::inherits
[01:28:09.480]                       invokeRestart <- base::invokeRestart
[01:28:09.480]                       is.null <- base::is.null
[01:28:09.480]                       muffled <- FALSE
[01:28:09.480]                       if (inherits(cond, "message")) {
[01:28:09.480]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.480]                         if (muffled) 
[01:28:09.480]                           invokeRestart("muffleMessage")
[01:28:09.480]                       }
[01:28:09.480]                       else if (inherits(cond, "warning")) {
[01:28:09.480]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.480]                         if (muffled) 
[01:28:09.480]                           invokeRestart("muffleWarning")
[01:28:09.480]                       }
[01:28:09.480]                       else if (inherits(cond, "condition")) {
[01:28:09.480]                         if (!is.null(pattern)) {
[01:28:09.480]                           computeRestarts <- base::computeRestarts
[01:28:09.480]                           grepl <- base::grepl
[01:28:09.480]                           restarts <- computeRestarts(cond)
[01:28:09.480]                           for (restart in restarts) {
[01:28:09.480]                             name <- restart$name
[01:28:09.480]                             if (is.null(name)) 
[01:28:09.480]                               next
[01:28:09.480]                             if (!grepl(pattern, name)) 
[01:28:09.480]                               next
[01:28:09.480]                             invokeRestart(restart)
[01:28:09.480]                             muffled <- TRUE
[01:28:09.480]                             break
[01:28:09.480]                           }
[01:28:09.480]                         }
[01:28:09.480]                       }
[01:28:09.480]                       invisible(muffled)
[01:28:09.480]                     }
[01:28:09.480]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.480]                   }
[01:28:09.480]                 }
[01:28:09.480]             }
[01:28:09.480]         }))
[01:28:09.480]     }, error = function(ex) {
[01:28:09.480]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.480]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.480]                 ...future.rng), started = ...future.startTime, 
[01:28:09.480]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.480]             version = "1.8"), class = "FutureResult")
[01:28:09.480]     }, finally = {
[01:28:09.480]         if (!identical(...future.workdir, getwd())) 
[01:28:09.480]             setwd(...future.workdir)
[01:28:09.480]         {
[01:28:09.480]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.480]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.480]             }
[01:28:09.480]             base::options(...future.oldOptions)
[01:28:09.480]             if (.Platform$OS.type == "windows") {
[01:28:09.480]                 old_names <- names(...future.oldEnvVars)
[01:28:09.480]                 envs <- base::Sys.getenv()
[01:28:09.480]                 names <- names(envs)
[01:28:09.480]                 common <- intersect(names, old_names)
[01:28:09.480]                 added <- setdiff(names, old_names)
[01:28:09.480]                 removed <- setdiff(old_names, names)
[01:28:09.480]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.480]                   envs[common]]
[01:28:09.480]                 NAMES <- toupper(changed)
[01:28:09.480]                 args <- list()
[01:28:09.480]                 for (kk in seq_along(NAMES)) {
[01:28:09.480]                   name <- changed[[kk]]
[01:28:09.480]                   NAME <- NAMES[[kk]]
[01:28:09.480]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.480]                     next
[01:28:09.480]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.480]                 }
[01:28:09.480]                 NAMES <- toupper(added)
[01:28:09.480]                 for (kk in seq_along(NAMES)) {
[01:28:09.480]                   name <- added[[kk]]
[01:28:09.480]                   NAME <- NAMES[[kk]]
[01:28:09.480]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.480]                     next
[01:28:09.480]                   args[[name]] <- ""
[01:28:09.480]                 }
[01:28:09.480]                 NAMES <- toupper(removed)
[01:28:09.480]                 for (kk in seq_along(NAMES)) {
[01:28:09.480]                   name <- removed[[kk]]
[01:28:09.480]                   NAME <- NAMES[[kk]]
[01:28:09.480]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.480]                     next
[01:28:09.480]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.480]                 }
[01:28:09.480]                 if (length(args) > 0) 
[01:28:09.480]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.480]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.480]             }
[01:28:09.480]             else {
[01:28:09.480]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.480]             }
[01:28:09.480]             {
[01:28:09.480]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.480]                   0L) {
[01:28:09.480]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.480]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.480]                   base::options(opts)
[01:28:09.480]                 }
[01:28:09.480]                 {
[01:28:09.480]                   {
[01:28:09.480]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.480]                     NULL
[01:28:09.480]                   }
[01:28:09.480]                   options(future.plan = NULL)
[01:28:09.480]                   if (is.na(NA_character_)) 
[01:28:09.480]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.480]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.480]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.480]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.480]                     envir = parent.frame()) 
[01:28:09.480]                   {
[01:28:09.480]                     if (is.function(workers)) 
[01:28:09.480]                       workers <- workers()
[01:28:09.480]                     workers <- structure(as.integer(workers), 
[01:28:09.480]                       class = class(workers))
[01:28:09.480]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.480]                       workers >= 1)
[01:28:09.480]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.480]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.480]                     }
[01:28:09.480]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.480]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.480]                       envir = envir)
[01:28:09.480]                     if (!future$lazy) 
[01:28:09.480]                       future <- run(future)
[01:28:09.480]                     invisible(future)
[01:28:09.480]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.480]                 }
[01:28:09.480]             }
[01:28:09.480]         }
[01:28:09.480]     })
[01:28:09.480]     if (TRUE) {
[01:28:09.480]         base::sink(type = "output", split = FALSE)
[01:28:09.480]         if (TRUE) {
[01:28:09.480]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.480]         }
[01:28:09.480]         else {
[01:28:09.480]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.480]         }
[01:28:09.480]         base::close(...future.stdout)
[01:28:09.480]         ...future.stdout <- NULL
[01:28:09.480]     }
[01:28:09.480]     ...future.result$conditions <- ...future.conditions
[01:28:09.480]     ...future.result$finished <- base::Sys.time()
[01:28:09.480]     ...future.result
[01:28:09.480] }
[01:28:09.485] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:28:09.485] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:09.486] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:09.486] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:28:09.487] MultisessionFuture started
[01:28:09.487] - Launch lazy future ... done
[01:28:09.487] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.488] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.488] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.490] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:09.490] Searching for globals ... DONE
[01:28:09.490] Resolving globals: TRUE
[01:28:09.490] Resolving any globals that are futures ...
[01:28:09.490] - globals: [4] '{', '<-', '*', 'ii'
[01:28:09.490] Resolving any globals that are futures ... DONE
[01:28:09.491] Resolving futures part of globals (recursively) ...
[01:28:09.491] resolve() on list ...
[01:28:09.491]  recursive: 99
[01:28:09.492]  length: 1
[01:28:09.492]  elements: 'ii'
[01:28:09.492]  length: 0 (resolved future 1)
[01:28:09.492] resolve() on list ... DONE
[01:28:09.492] - globals: [1] 'ii'
[01:28:09.492] Resolving futures part of globals (recursively) ... DONE
[01:28:09.493] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:09.493] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:09.493] - globals: [1] 'ii'
[01:28:09.494] 
[01:28:09.494] getGlobalsAndPackages() ... DONE
[01:28:09.494] run() for 'Future' ...
[01:28:09.494] - state: 'created'
[01:28:09.494] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.509] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.509] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.509]   - Field: 'node'
[01:28:09.509]   - Field: 'label'
[01:28:09.510]   - Field: 'local'
[01:28:09.510]   - Field: 'owner'
[01:28:09.510]   - Field: 'envir'
[01:28:09.510]   - Field: 'workers'
[01:28:09.510]   - Field: 'packages'
[01:28:09.511]   - Field: 'gc'
[01:28:09.511]   - Field: 'conditions'
[01:28:09.511]   - Field: 'persistent'
[01:28:09.511]   - Field: 'expr'
[01:28:09.511]   - Field: 'uuid'
[01:28:09.512]   - Field: 'seed'
[01:28:09.512]   - Field: 'version'
[01:28:09.512]   - Field: 'result'
[01:28:09.512]   - Field: 'asynchronous'
[01:28:09.512]   - Field: 'calls'
[01:28:09.512]   - Field: 'globals'
[01:28:09.513]   - Field: 'stdout'
[01:28:09.513]   - Field: 'earlySignal'
[01:28:09.513]   - Field: 'lazy'
[01:28:09.513]   - Field: 'state'
[01:28:09.513] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.513] - Launch lazy future ...
[01:28:09.514] Packages needed by the future expression (n = 0): <none>
[01:28:09.514] Packages needed by future strategies (n = 0): <none>
[01:28:09.515] {
[01:28:09.515]     {
[01:28:09.515]         {
[01:28:09.515]             ...future.startTime <- base::Sys.time()
[01:28:09.515]             {
[01:28:09.515]                 {
[01:28:09.515]                   {
[01:28:09.515]                     {
[01:28:09.515]                       base::local({
[01:28:09.515]                         has_future <- base::requireNamespace("future", 
[01:28:09.515]                           quietly = TRUE)
[01:28:09.515]                         if (has_future) {
[01:28:09.515]                           ns <- base::getNamespace("future")
[01:28:09.515]                           version <- ns[[".package"]][["version"]]
[01:28:09.515]                           if (is.null(version)) 
[01:28:09.515]                             version <- utils::packageVersion("future")
[01:28:09.515]                         }
[01:28:09.515]                         else {
[01:28:09.515]                           version <- NULL
[01:28:09.515]                         }
[01:28:09.515]                         if (!has_future || version < "1.8.0") {
[01:28:09.515]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.515]                             "", base::R.version$version.string), 
[01:28:09.515]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.515]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.515]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.515]                               "release", "version")], collapse = " "), 
[01:28:09.515]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.515]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.515]                             info)
[01:28:09.515]                           info <- base::paste(info, collapse = "; ")
[01:28:09.515]                           if (!has_future) {
[01:28:09.515]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.515]                               info)
[01:28:09.515]                           }
[01:28:09.515]                           else {
[01:28:09.515]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.515]                               info, version)
[01:28:09.515]                           }
[01:28:09.515]                           base::stop(msg)
[01:28:09.515]                         }
[01:28:09.515]                       })
[01:28:09.515]                     }
[01:28:09.515]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.515]                     base::options(mc.cores = 1L)
[01:28:09.515]                   }
[01:28:09.515]                   options(future.plan = NULL)
[01:28:09.515]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.515]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.515]                 }
[01:28:09.515]                 ...future.workdir <- getwd()
[01:28:09.515]             }
[01:28:09.515]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.515]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.515]         }
[01:28:09.515]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.515]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.515]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.515]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.515]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.515]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.515]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.515]             base::names(...future.oldOptions))
[01:28:09.515]     }
[01:28:09.515]     if (FALSE) {
[01:28:09.515]     }
[01:28:09.515]     else {
[01:28:09.515]         if (TRUE) {
[01:28:09.515]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.515]                 open = "w")
[01:28:09.515]         }
[01:28:09.515]         else {
[01:28:09.515]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.515]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.515]         }
[01:28:09.515]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.515]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.515]             base::sink(type = "output", split = FALSE)
[01:28:09.515]             base::close(...future.stdout)
[01:28:09.515]         }, add = TRUE)
[01:28:09.515]     }
[01:28:09.515]     ...future.frame <- base::sys.nframe()
[01:28:09.515]     ...future.conditions <- base::list()
[01:28:09.515]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.515]     if (FALSE) {
[01:28:09.515]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.515]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.515]     }
[01:28:09.515]     ...future.result <- base::tryCatch({
[01:28:09.515]         base::withCallingHandlers({
[01:28:09.515]             ...future.value <- base::withVisible(base::local({
[01:28:09.515]                 ...future.makeSendCondition <- base::local({
[01:28:09.515]                   sendCondition <- NULL
[01:28:09.515]                   function(frame = 1L) {
[01:28:09.515]                     if (is.function(sendCondition)) 
[01:28:09.515]                       return(sendCondition)
[01:28:09.515]                     ns <- getNamespace("parallel")
[01:28:09.515]                     if (exists("sendData", mode = "function", 
[01:28:09.515]                       envir = ns)) {
[01:28:09.515]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.515]                         envir = ns)
[01:28:09.515]                       envir <- sys.frame(frame)
[01:28:09.515]                       master <- NULL
[01:28:09.515]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.515]                         !identical(envir, emptyenv())) {
[01:28:09.515]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.515]                           inherits = FALSE)) {
[01:28:09.515]                           master <- get("master", mode = "list", 
[01:28:09.515]                             envir = envir, inherits = FALSE)
[01:28:09.515]                           if (inherits(master, c("SOCKnode", 
[01:28:09.515]                             "SOCK0node"))) {
[01:28:09.515]                             sendCondition <<- function(cond) {
[01:28:09.515]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.515]                                 success = TRUE)
[01:28:09.515]                               parallel_sendData(master, data)
[01:28:09.515]                             }
[01:28:09.515]                             return(sendCondition)
[01:28:09.515]                           }
[01:28:09.515]                         }
[01:28:09.515]                         frame <- frame + 1L
[01:28:09.515]                         envir <- sys.frame(frame)
[01:28:09.515]                       }
[01:28:09.515]                     }
[01:28:09.515]                     sendCondition <<- function(cond) NULL
[01:28:09.515]                   }
[01:28:09.515]                 })
[01:28:09.515]                 withCallingHandlers({
[01:28:09.515]                   {
[01:28:09.515]                     b <- a * ii
[01:28:09.515]                     a <- 0
[01:28:09.515]                     b
[01:28:09.515]                   }
[01:28:09.515]                 }, immediateCondition = function(cond) {
[01:28:09.515]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.515]                   sendCondition(cond)
[01:28:09.515]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.515]                   {
[01:28:09.515]                     inherits <- base::inherits
[01:28:09.515]                     invokeRestart <- base::invokeRestart
[01:28:09.515]                     is.null <- base::is.null
[01:28:09.515]                     muffled <- FALSE
[01:28:09.515]                     if (inherits(cond, "message")) {
[01:28:09.515]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.515]                       if (muffled) 
[01:28:09.515]                         invokeRestart("muffleMessage")
[01:28:09.515]                     }
[01:28:09.515]                     else if (inherits(cond, "warning")) {
[01:28:09.515]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.515]                       if (muffled) 
[01:28:09.515]                         invokeRestart("muffleWarning")
[01:28:09.515]                     }
[01:28:09.515]                     else if (inherits(cond, "condition")) {
[01:28:09.515]                       if (!is.null(pattern)) {
[01:28:09.515]                         computeRestarts <- base::computeRestarts
[01:28:09.515]                         grepl <- base::grepl
[01:28:09.515]                         restarts <- computeRestarts(cond)
[01:28:09.515]                         for (restart in restarts) {
[01:28:09.515]                           name <- restart$name
[01:28:09.515]                           if (is.null(name)) 
[01:28:09.515]                             next
[01:28:09.515]                           if (!grepl(pattern, name)) 
[01:28:09.515]                             next
[01:28:09.515]                           invokeRestart(restart)
[01:28:09.515]                           muffled <- TRUE
[01:28:09.515]                           break
[01:28:09.515]                         }
[01:28:09.515]                       }
[01:28:09.515]                     }
[01:28:09.515]                     invisible(muffled)
[01:28:09.515]                   }
[01:28:09.515]                   muffleCondition(cond)
[01:28:09.515]                 })
[01:28:09.515]             }))
[01:28:09.515]             future::FutureResult(value = ...future.value$value, 
[01:28:09.515]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.515]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.515]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.515]                     ...future.globalenv.names))
[01:28:09.515]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.515]         }, condition = base::local({
[01:28:09.515]             c <- base::c
[01:28:09.515]             inherits <- base::inherits
[01:28:09.515]             invokeRestart <- base::invokeRestart
[01:28:09.515]             length <- base::length
[01:28:09.515]             list <- base::list
[01:28:09.515]             seq.int <- base::seq.int
[01:28:09.515]             signalCondition <- base::signalCondition
[01:28:09.515]             sys.calls <- base::sys.calls
[01:28:09.515]             `[[` <- base::`[[`
[01:28:09.515]             `+` <- base::`+`
[01:28:09.515]             `<<-` <- base::`<<-`
[01:28:09.515]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.515]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.515]                   3L)]
[01:28:09.515]             }
[01:28:09.515]             function(cond) {
[01:28:09.515]                 is_error <- inherits(cond, "error")
[01:28:09.515]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.515]                   NULL)
[01:28:09.515]                 if (is_error) {
[01:28:09.515]                   sessionInformation <- function() {
[01:28:09.515]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.515]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.515]                       search = base::search(), system = base::Sys.info())
[01:28:09.515]                   }
[01:28:09.515]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.515]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.515]                     cond$call), session = sessionInformation(), 
[01:28:09.515]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.515]                   signalCondition(cond)
[01:28:09.515]                 }
[01:28:09.515]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.515]                 "immediateCondition"))) {
[01:28:09.515]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.515]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.515]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.515]                   if (TRUE && !signal) {
[01:28:09.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.515]                     {
[01:28:09.515]                       inherits <- base::inherits
[01:28:09.515]                       invokeRestart <- base::invokeRestart
[01:28:09.515]                       is.null <- base::is.null
[01:28:09.515]                       muffled <- FALSE
[01:28:09.515]                       if (inherits(cond, "message")) {
[01:28:09.515]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.515]                         if (muffled) 
[01:28:09.515]                           invokeRestart("muffleMessage")
[01:28:09.515]                       }
[01:28:09.515]                       else if (inherits(cond, "warning")) {
[01:28:09.515]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.515]                         if (muffled) 
[01:28:09.515]                           invokeRestart("muffleWarning")
[01:28:09.515]                       }
[01:28:09.515]                       else if (inherits(cond, "condition")) {
[01:28:09.515]                         if (!is.null(pattern)) {
[01:28:09.515]                           computeRestarts <- base::computeRestarts
[01:28:09.515]                           grepl <- base::grepl
[01:28:09.515]                           restarts <- computeRestarts(cond)
[01:28:09.515]                           for (restart in restarts) {
[01:28:09.515]                             name <- restart$name
[01:28:09.515]                             if (is.null(name)) 
[01:28:09.515]                               next
[01:28:09.515]                             if (!grepl(pattern, name)) 
[01:28:09.515]                               next
[01:28:09.515]                             invokeRestart(restart)
[01:28:09.515]                             muffled <- TRUE
[01:28:09.515]                             break
[01:28:09.515]                           }
[01:28:09.515]                         }
[01:28:09.515]                       }
[01:28:09.515]                       invisible(muffled)
[01:28:09.515]                     }
[01:28:09.515]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.515]                   }
[01:28:09.515]                 }
[01:28:09.515]                 else {
[01:28:09.515]                   if (TRUE) {
[01:28:09.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.515]                     {
[01:28:09.515]                       inherits <- base::inherits
[01:28:09.515]                       invokeRestart <- base::invokeRestart
[01:28:09.515]                       is.null <- base::is.null
[01:28:09.515]                       muffled <- FALSE
[01:28:09.515]                       if (inherits(cond, "message")) {
[01:28:09.515]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.515]                         if (muffled) 
[01:28:09.515]                           invokeRestart("muffleMessage")
[01:28:09.515]                       }
[01:28:09.515]                       else if (inherits(cond, "warning")) {
[01:28:09.515]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.515]                         if (muffled) 
[01:28:09.515]                           invokeRestart("muffleWarning")
[01:28:09.515]                       }
[01:28:09.515]                       else if (inherits(cond, "condition")) {
[01:28:09.515]                         if (!is.null(pattern)) {
[01:28:09.515]                           computeRestarts <- base::computeRestarts
[01:28:09.515]                           grepl <- base::grepl
[01:28:09.515]                           restarts <- computeRestarts(cond)
[01:28:09.515]                           for (restart in restarts) {
[01:28:09.515]                             name <- restart$name
[01:28:09.515]                             if (is.null(name)) 
[01:28:09.515]                               next
[01:28:09.515]                             if (!grepl(pattern, name)) 
[01:28:09.515]                               next
[01:28:09.515]                             invokeRestart(restart)
[01:28:09.515]                             muffled <- TRUE
[01:28:09.515]                             break
[01:28:09.515]                           }
[01:28:09.515]                         }
[01:28:09.515]                       }
[01:28:09.515]                       invisible(muffled)
[01:28:09.515]                     }
[01:28:09.515]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.515]                   }
[01:28:09.515]                 }
[01:28:09.515]             }
[01:28:09.515]         }))
[01:28:09.515]     }, error = function(ex) {
[01:28:09.515]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.515]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.515]                 ...future.rng), started = ...future.startTime, 
[01:28:09.515]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.515]             version = "1.8"), class = "FutureResult")
[01:28:09.515]     }, finally = {
[01:28:09.515]         if (!identical(...future.workdir, getwd())) 
[01:28:09.515]             setwd(...future.workdir)
[01:28:09.515]         {
[01:28:09.515]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.515]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.515]             }
[01:28:09.515]             base::options(...future.oldOptions)
[01:28:09.515]             if (.Platform$OS.type == "windows") {
[01:28:09.515]                 old_names <- names(...future.oldEnvVars)
[01:28:09.515]                 envs <- base::Sys.getenv()
[01:28:09.515]                 names <- names(envs)
[01:28:09.515]                 common <- intersect(names, old_names)
[01:28:09.515]                 added <- setdiff(names, old_names)
[01:28:09.515]                 removed <- setdiff(old_names, names)
[01:28:09.515]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.515]                   envs[common]]
[01:28:09.515]                 NAMES <- toupper(changed)
[01:28:09.515]                 args <- list()
[01:28:09.515]                 for (kk in seq_along(NAMES)) {
[01:28:09.515]                   name <- changed[[kk]]
[01:28:09.515]                   NAME <- NAMES[[kk]]
[01:28:09.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.515]                     next
[01:28:09.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.515]                 }
[01:28:09.515]                 NAMES <- toupper(added)
[01:28:09.515]                 for (kk in seq_along(NAMES)) {
[01:28:09.515]                   name <- added[[kk]]
[01:28:09.515]                   NAME <- NAMES[[kk]]
[01:28:09.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.515]                     next
[01:28:09.515]                   args[[name]] <- ""
[01:28:09.515]                 }
[01:28:09.515]                 NAMES <- toupper(removed)
[01:28:09.515]                 for (kk in seq_along(NAMES)) {
[01:28:09.515]                   name <- removed[[kk]]
[01:28:09.515]                   NAME <- NAMES[[kk]]
[01:28:09.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.515]                     next
[01:28:09.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.515]                 }
[01:28:09.515]                 if (length(args) > 0) 
[01:28:09.515]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.515]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.515]             }
[01:28:09.515]             else {
[01:28:09.515]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.515]             }
[01:28:09.515]             {
[01:28:09.515]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.515]                   0L) {
[01:28:09.515]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.515]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.515]                   base::options(opts)
[01:28:09.515]                 }
[01:28:09.515]                 {
[01:28:09.515]                   {
[01:28:09.515]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.515]                     NULL
[01:28:09.515]                   }
[01:28:09.515]                   options(future.plan = NULL)
[01:28:09.515]                   if (is.na(NA_character_)) 
[01:28:09.515]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.515]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.515]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.515]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.515]                     envir = parent.frame()) 
[01:28:09.515]                   {
[01:28:09.515]                     if (is.function(workers)) 
[01:28:09.515]                       workers <- workers()
[01:28:09.515]                     workers <- structure(as.integer(workers), 
[01:28:09.515]                       class = class(workers))
[01:28:09.515]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.515]                       workers >= 1)
[01:28:09.515]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.515]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.515]                     }
[01:28:09.515]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.515]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.515]                       envir = envir)
[01:28:09.515]                     if (!future$lazy) 
[01:28:09.515]                       future <- run(future)
[01:28:09.515]                     invisible(future)
[01:28:09.515]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.515]                 }
[01:28:09.515]             }
[01:28:09.515]         }
[01:28:09.515]     })
[01:28:09.515]     if (TRUE) {
[01:28:09.515]         base::sink(type = "output", split = FALSE)
[01:28:09.515]         if (TRUE) {
[01:28:09.515]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.515]         }
[01:28:09.515]         else {
[01:28:09.515]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.515]         }
[01:28:09.515]         base::close(...future.stdout)
[01:28:09.515]         ...future.stdout <- NULL
[01:28:09.515]     }
[01:28:09.515]     ...future.result$conditions <- ...future.conditions
[01:28:09.515]     ...future.result$finished <- base::Sys.time()
[01:28:09.515]     ...future.result
[01:28:09.515] }
[01:28:09.600] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[01:28:09.600] Exporting 'ii' (56 bytes) to cluster node #2 ...
[01:28:09.601] Exporting 'ii' (56 bytes) to cluster node #2 ... DONE
[01:28:09.601] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[01:28:09.601] MultisessionFuture started
[01:28:09.602] - Launch lazy future ... done
[01:28:09.602] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.603] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.603] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.605] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:09.605] Searching for globals ... DONE
[01:28:09.605] Resolving globals: TRUE
[01:28:09.605] Resolving any globals that are futures ...
[01:28:09.605] - globals: [4] '{', '<-', '*', 'ii'
[01:28:09.606] Resolving any globals that are futures ... DONE
[01:28:09.606] Resolving futures part of globals (recursively) ...
[01:28:09.607] resolve() on list ...
[01:28:09.607]  recursive: 99
[01:28:09.607]  length: 1
[01:28:09.607]  elements: 'ii'
[01:28:09.607]  length: 0 (resolved future 1)
[01:28:09.607] resolve() on list ... DONE
[01:28:09.608] - globals: [1] 'ii'
[01:28:09.608] Resolving futures part of globals (recursively) ... DONE
[01:28:09.608] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:09.608] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:09.609] - globals: [1] 'ii'
[01:28:09.609] 
[01:28:09.609] getGlobalsAndPackages() ... DONE
[01:28:09.609] run() for 'Future' ...
[01:28:09.609] - state: 'created'
[01:28:09.610] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.624] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.624] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.625]   - Field: 'node'
[01:28:09.625]   - Field: 'label'
[01:28:09.625]   - Field: 'local'
[01:28:09.625]   - Field: 'owner'
[01:28:09.625]   - Field: 'envir'
[01:28:09.626]   - Field: 'workers'
[01:28:09.626]   - Field: 'packages'
[01:28:09.626]   - Field: 'gc'
[01:28:09.626]   - Field: 'conditions'
[01:28:09.626]   - Field: 'persistent'
[01:28:09.626]   - Field: 'expr'
[01:28:09.627]   - Field: 'uuid'
[01:28:09.627]   - Field: 'seed'
[01:28:09.627]   - Field: 'version'
[01:28:09.627]   - Field: 'result'
[01:28:09.627]   - Field: 'asynchronous'
[01:28:09.628]   - Field: 'calls'
[01:28:09.628]   - Field: 'globals'
[01:28:09.628]   - Field: 'stdout'
[01:28:09.628]   - Field: 'earlySignal'
[01:28:09.628]   - Field: 'lazy'
[01:28:09.628]   - Field: 'state'
[01:28:09.629] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.629] - Launch lazy future ...
[01:28:09.629] Packages needed by the future expression (n = 0): <none>
[01:28:09.629] Packages needed by future strategies (n = 0): <none>
[01:28:09.630] {
[01:28:09.630]     {
[01:28:09.630]         {
[01:28:09.630]             ...future.startTime <- base::Sys.time()
[01:28:09.630]             {
[01:28:09.630]                 {
[01:28:09.630]                   {
[01:28:09.630]                     {
[01:28:09.630]                       base::local({
[01:28:09.630]                         has_future <- base::requireNamespace("future", 
[01:28:09.630]                           quietly = TRUE)
[01:28:09.630]                         if (has_future) {
[01:28:09.630]                           ns <- base::getNamespace("future")
[01:28:09.630]                           version <- ns[[".package"]][["version"]]
[01:28:09.630]                           if (is.null(version)) 
[01:28:09.630]                             version <- utils::packageVersion("future")
[01:28:09.630]                         }
[01:28:09.630]                         else {
[01:28:09.630]                           version <- NULL
[01:28:09.630]                         }
[01:28:09.630]                         if (!has_future || version < "1.8.0") {
[01:28:09.630]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.630]                             "", base::R.version$version.string), 
[01:28:09.630]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.630]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.630]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.630]                               "release", "version")], collapse = " "), 
[01:28:09.630]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.630]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.630]                             info)
[01:28:09.630]                           info <- base::paste(info, collapse = "; ")
[01:28:09.630]                           if (!has_future) {
[01:28:09.630]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.630]                               info)
[01:28:09.630]                           }
[01:28:09.630]                           else {
[01:28:09.630]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.630]                               info, version)
[01:28:09.630]                           }
[01:28:09.630]                           base::stop(msg)
[01:28:09.630]                         }
[01:28:09.630]                       })
[01:28:09.630]                     }
[01:28:09.630]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.630]                     base::options(mc.cores = 1L)
[01:28:09.630]                   }
[01:28:09.630]                   options(future.plan = NULL)
[01:28:09.630]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.630]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.630]                 }
[01:28:09.630]                 ...future.workdir <- getwd()
[01:28:09.630]             }
[01:28:09.630]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.630]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.630]         }
[01:28:09.630]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.630]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.630]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.630]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.630]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.630]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.630]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.630]             base::names(...future.oldOptions))
[01:28:09.630]     }
[01:28:09.630]     if (FALSE) {
[01:28:09.630]     }
[01:28:09.630]     else {
[01:28:09.630]         if (TRUE) {
[01:28:09.630]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.630]                 open = "w")
[01:28:09.630]         }
[01:28:09.630]         else {
[01:28:09.630]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.630]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.630]         }
[01:28:09.630]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.630]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.630]             base::sink(type = "output", split = FALSE)
[01:28:09.630]             base::close(...future.stdout)
[01:28:09.630]         }, add = TRUE)
[01:28:09.630]     }
[01:28:09.630]     ...future.frame <- base::sys.nframe()
[01:28:09.630]     ...future.conditions <- base::list()
[01:28:09.630]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.630]     if (FALSE) {
[01:28:09.630]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.630]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.630]     }
[01:28:09.630]     ...future.result <- base::tryCatch({
[01:28:09.630]         base::withCallingHandlers({
[01:28:09.630]             ...future.value <- base::withVisible(base::local({
[01:28:09.630]                 ...future.makeSendCondition <- base::local({
[01:28:09.630]                   sendCondition <- NULL
[01:28:09.630]                   function(frame = 1L) {
[01:28:09.630]                     if (is.function(sendCondition)) 
[01:28:09.630]                       return(sendCondition)
[01:28:09.630]                     ns <- getNamespace("parallel")
[01:28:09.630]                     if (exists("sendData", mode = "function", 
[01:28:09.630]                       envir = ns)) {
[01:28:09.630]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.630]                         envir = ns)
[01:28:09.630]                       envir <- sys.frame(frame)
[01:28:09.630]                       master <- NULL
[01:28:09.630]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.630]                         !identical(envir, emptyenv())) {
[01:28:09.630]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.630]                           inherits = FALSE)) {
[01:28:09.630]                           master <- get("master", mode = "list", 
[01:28:09.630]                             envir = envir, inherits = FALSE)
[01:28:09.630]                           if (inherits(master, c("SOCKnode", 
[01:28:09.630]                             "SOCK0node"))) {
[01:28:09.630]                             sendCondition <<- function(cond) {
[01:28:09.630]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.630]                                 success = TRUE)
[01:28:09.630]                               parallel_sendData(master, data)
[01:28:09.630]                             }
[01:28:09.630]                             return(sendCondition)
[01:28:09.630]                           }
[01:28:09.630]                         }
[01:28:09.630]                         frame <- frame + 1L
[01:28:09.630]                         envir <- sys.frame(frame)
[01:28:09.630]                       }
[01:28:09.630]                     }
[01:28:09.630]                     sendCondition <<- function(cond) NULL
[01:28:09.630]                   }
[01:28:09.630]                 })
[01:28:09.630]                 withCallingHandlers({
[01:28:09.630]                   {
[01:28:09.630]                     b <- a * ii
[01:28:09.630]                     a <- 0
[01:28:09.630]                     b
[01:28:09.630]                   }
[01:28:09.630]                 }, immediateCondition = function(cond) {
[01:28:09.630]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.630]                   sendCondition(cond)
[01:28:09.630]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.630]                   {
[01:28:09.630]                     inherits <- base::inherits
[01:28:09.630]                     invokeRestart <- base::invokeRestart
[01:28:09.630]                     is.null <- base::is.null
[01:28:09.630]                     muffled <- FALSE
[01:28:09.630]                     if (inherits(cond, "message")) {
[01:28:09.630]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.630]                       if (muffled) 
[01:28:09.630]                         invokeRestart("muffleMessage")
[01:28:09.630]                     }
[01:28:09.630]                     else if (inherits(cond, "warning")) {
[01:28:09.630]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.630]                       if (muffled) 
[01:28:09.630]                         invokeRestart("muffleWarning")
[01:28:09.630]                     }
[01:28:09.630]                     else if (inherits(cond, "condition")) {
[01:28:09.630]                       if (!is.null(pattern)) {
[01:28:09.630]                         computeRestarts <- base::computeRestarts
[01:28:09.630]                         grepl <- base::grepl
[01:28:09.630]                         restarts <- computeRestarts(cond)
[01:28:09.630]                         for (restart in restarts) {
[01:28:09.630]                           name <- restart$name
[01:28:09.630]                           if (is.null(name)) 
[01:28:09.630]                             next
[01:28:09.630]                           if (!grepl(pattern, name)) 
[01:28:09.630]                             next
[01:28:09.630]                           invokeRestart(restart)
[01:28:09.630]                           muffled <- TRUE
[01:28:09.630]                           break
[01:28:09.630]                         }
[01:28:09.630]                       }
[01:28:09.630]                     }
[01:28:09.630]                     invisible(muffled)
[01:28:09.630]                   }
[01:28:09.630]                   muffleCondition(cond)
[01:28:09.630]                 })
[01:28:09.630]             }))
[01:28:09.630]             future::FutureResult(value = ...future.value$value, 
[01:28:09.630]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.630]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.630]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.630]                     ...future.globalenv.names))
[01:28:09.630]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.630]         }, condition = base::local({
[01:28:09.630]             c <- base::c
[01:28:09.630]             inherits <- base::inherits
[01:28:09.630]             invokeRestart <- base::invokeRestart
[01:28:09.630]             length <- base::length
[01:28:09.630]             list <- base::list
[01:28:09.630]             seq.int <- base::seq.int
[01:28:09.630]             signalCondition <- base::signalCondition
[01:28:09.630]             sys.calls <- base::sys.calls
[01:28:09.630]             `[[` <- base::`[[`
[01:28:09.630]             `+` <- base::`+`
[01:28:09.630]             `<<-` <- base::`<<-`
[01:28:09.630]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.630]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.630]                   3L)]
[01:28:09.630]             }
[01:28:09.630]             function(cond) {
[01:28:09.630]                 is_error <- inherits(cond, "error")
[01:28:09.630]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.630]                   NULL)
[01:28:09.630]                 if (is_error) {
[01:28:09.630]                   sessionInformation <- function() {
[01:28:09.630]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.630]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.630]                       search = base::search(), system = base::Sys.info())
[01:28:09.630]                   }
[01:28:09.630]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.630]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.630]                     cond$call), session = sessionInformation(), 
[01:28:09.630]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.630]                   signalCondition(cond)
[01:28:09.630]                 }
[01:28:09.630]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.630]                 "immediateCondition"))) {
[01:28:09.630]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.630]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.630]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.630]                   if (TRUE && !signal) {
[01:28:09.630]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.630]                     {
[01:28:09.630]                       inherits <- base::inherits
[01:28:09.630]                       invokeRestart <- base::invokeRestart
[01:28:09.630]                       is.null <- base::is.null
[01:28:09.630]                       muffled <- FALSE
[01:28:09.630]                       if (inherits(cond, "message")) {
[01:28:09.630]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.630]                         if (muffled) 
[01:28:09.630]                           invokeRestart("muffleMessage")
[01:28:09.630]                       }
[01:28:09.630]                       else if (inherits(cond, "warning")) {
[01:28:09.630]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.630]                         if (muffled) 
[01:28:09.630]                           invokeRestart("muffleWarning")
[01:28:09.630]                       }
[01:28:09.630]                       else if (inherits(cond, "condition")) {
[01:28:09.630]                         if (!is.null(pattern)) {
[01:28:09.630]                           computeRestarts <- base::computeRestarts
[01:28:09.630]                           grepl <- base::grepl
[01:28:09.630]                           restarts <- computeRestarts(cond)
[01:28:09.630]                           for (restart in restarts) {
[01:28:09.630]                             name <- restart$name
[01:28:09.630]                             if (is.null(name)) 
[01:28:09.630]                               next
[01:28:09.630]                             if (!grepl(pattern, name)) 
[01:28:09.630]                               next
[01:28:09.630]                             invokeRestart(restart)
[01:28:09.630]                             muffled <- TRUE
[01:28:09.630]                             break
[01:28:09.630]                           }
[01:28:09.630]                         }
[01:28:09.630]                       }
[01:28:09.630]                       invisible(muffled)
[01:28:09.630]                     }
[01:28:09.630]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.630]                   }
[01:28:09.630]                 }
[01:28:09.630]                 else {
[01:28:09.630]                   if (TRUE) {
[01:28:09.630]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.630]                     {
[01:28:09.630]                       inherits <- base::inherits
[01:28:09.630]                       invokeRestart <- base::invokeRestart
[01:28:09.630]                       is.null <- base::is.null
[01:28:09.630]                       muffled <- FALSE
[01:28:09.630]                       if (inherits(cond, "message")) {
[01:28:09.630]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.630]                         if (muffled) 
[01:28:09.630]                           invokeRestart("muffleMessage")
[01:28:09.630]                       }
[01:28:09.630]                       else if (inherits(cond, "warning")) {
[01:28:09.630]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.630]                         if (muffled) 
[01:28:09.630]                           invokeRestart("muffleWarning")
[01:28:09.630]                       }
[01:28:09.630]                       else if (inherits(cond, "condition")) {
[01:28:09.630]                         if (!is.null(pattern)) {
[01:28:09.630]                           computeRestarts <- base::computeRestarts
[01:28:09.630]                           grepl <- base::grepl
[01:28:09.630]                           restarts <- computeRestarts(cond)
[01:28:09.630]                           for (restart in restarts) {
[01:28:09.630]                             name <- restart$name
[01:28:09.630]                             if (is.null(name)) 
[01:28:09.630]                               next
[01:28:09.630]                             if (!grepl(pattern, name)) 
[01:28:09.630]                               next
[01:28:09.630]                             invokeRestart(restart)
[01:28:09.630]                             muffled <- TRUE
[01:28:09.630]                             break
[01:28:09.630]                           }
[01:28:09.630]                         }
[01:28:09.630]                       }
[01:28:09.630]                       invisible(muffled)
[01:28:09.630]                     }
[01:28:09.630]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.630]                   }
[01:28:09.630]                 }
[01:28:09.630]             }
[01:28:09.630]         }))
[01:28:09.630]     }, error = function(ex) {
[01:28:09.630]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.630]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.630]                 ...future.rng), started = ...future.startTime, 
[01:28:09.630]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.630]             version = "1.8"), class = "FutureResult")
[01:28:09.630]     }, finally = {
[01:28:09.630]         if (!identical(...future.workdir, getwd())) 
[01:28:09.630]             setwd(...future.workdir)
[01:28:09.630]         {
[01:28:09.630]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.630]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.630]             }
[01:28:09.630]             base::options(...future.oldOptions)
[01:28:09.630]             if (.Platform$OS.type == "windows") {
[01:28:09.630]                 old_names <- names(...future.oldEnvVars)
[01:28:09.630]                 envs <- base::Sys.getenv()
[01:28:09.630]                 names <- names(envs)
[01:28:09.630]                 common <- intersect(names, old_names)
[01:28:09.630]                 added <- setdiff(names, old_names)
[01:28:09.630]                 removed <- setdiff(old_names, names)
[01:28:09.630]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.630]                   envs[common]]
[01:28:09.630]                 NAMES <- toupper(changed)
[01:28:09.630]                 args <- list()
[01:28:09.630]                 for (kk in seq_along(NAMES)) {
[01:28:09.630]                   name <- changed[[kk]]
[01:28:09.630]                   NAME <- NAMES[[kk]]
[01:28:09.630]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.630]                     next
[01:28:09.630]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.630]                 }
[01:28:09.630]                 NAMES <- toupper(added)
[01:28:09.630]                 for (kk in seq_along(NAMES)) {
[01:28:09.630]                   name <- added[[kk]]
[01:28:09.630]                   NAME <- NAMES[[kk]]
[01:28:09.630]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.630]                     next
[01:28:09.630]                   args[[name]] <- ""
[01:28:09.630]                 }
[01:28:09.630]                 NAMES <- toupper(removed)
[01:28:09.630]                 for (kk in seq_along(NAMES)) {
[01:28:09.630]                   name <- removed[[kk]]
[01:28:09.630]                   NAME <- NAMES[[kk]]
[01:28:09.630]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.630]                     next
[01:28:09.630]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.630]                 }
[01:28:09.630]                 if (length(args) > 0) 
[01:28:09.630]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.630]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.630]             }
[01:28:09.630]             else {
[01:28:09.630]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.630]             }
[01:28:09.630]             {
[01:28:09.630]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.630]                   0L) {
[01:28:09.630]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.630]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.630]                   base::options(opts)
[01:28:09.630]                 }
[01:28:09.630]                 {
[01:28:09.630]                   {
[01:28:09.630]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.630]                     NULL
[01:28:09.630]                   }
[01:28:09.630]                   options(future.plan = NULL)
[01:28:09.630]                   if (is.na(NA_character_)) 
[01:28:09.630]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.630]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.630]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.630]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.630]                     envir = parent.frame()) 
[01:28:09.630]                   {
[01:28:09.630]                     if (is.function(workers)) 
[01:28:09.630]                       workers <- workers()
[01:28:09.630]                     workers <- structure(as.integer(workers), 
[01:28:09.630]                       class = class(workers))
[01:28:09.630]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.630]                       workers >= 1)
[01:28:09.630]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.630]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.630]                     }
[01:28:09.630]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.630]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.630]                       envir = envir)
[01:28:09.630]                     if (!future$lazy) 
[01:28:09.630]                       future <- run(future)
[01:28:09.630]                     invisible(future)
[01:28:09.630]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.630]                 }
[01:28:09.630]             }
[01:28:09.630]         }
[01:28:09.630]     })
[01:28:09.630]     if (TRUE) {
[01:28:09.630]         base::sink(type = "output", split = FALSE)
[01:28:09.630]         if (TRUE) {
[01:28:09.630]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.630]         }
[01:28:09.630]         else {
[01:28:09.630]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.630]         }
[01:28:09.630]         base::close(...future.stdout)
[01:28:09.630]         ...future.stdout <- NULL
[01:28:09.630]     }
[01:28:09.630]     ...future.result$conditions <- ...future.conditions
[01:28:09.630]     ...future.result$finished <- base::Sys.time()
[01:28:09.630]     ...future.result
[01:28:09.630] }
[01:28:09.635] Poll #1 (0): usedNodes() = 2, workers = 2
[01:28:09.651] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.652] - Validating connection of MultisessionFuture
[01:28:09.652] - received message: FutureResult
[01:28:09.652] - Received FutureResult
[01:28:09.653] - Erased future from FutureRegistry
[01:28:09.653] result() for ClusterFuture ...
[01:28:09.653] - result already collected: FutureResult
[01:28:09.653] result() for ClusterFuture ... done
[01:28:09.653] signalConditions() ...
[01:28:09.653]  - include = 'immediateCondition'
[01:28:09.654]  - exclude = 
[01:28:09.654]  - resignal = FALSE
[01:28:09.654]  - Number of conditions: 1
[01:28:09.654] signalConditions() ... done
[01:28:09.654] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.654] result() for ClusterFuture ...
[01:28:09.655] - result already collected: FutureResult
[01:28:09.655] result() for ClusterFuture ... done
[01:28:09.655] result() for ClusterFuture ...
[01:28:09.655] - result already collected: FutureResult
[01:28:09.655] result() for ClusterFuture ... done
[01:28:09.655] signalConditions() ...
[01:28:09.656]  - include = 'immediateCondition'
[01:28:09.656]  - exclude = 
[01:28:09.656]  - resignal = FALSE
[01:28:09.656]  - Number of conditions: 1
[01:28:09.656] signalConditions() ... done
[01:28:09.657] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:28:09.657] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:09.658] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:09.658] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:28:09.659] MultisessionFuture started
[01:28:09.659] - Launch lazy future ... done
[01:28:09.659] run() for 'MultisessionFuture' ... done
[01:28:09.659] result() for ClusterFuture ...
[01:28:09.660] - result already collected: FutureResult
[01:28:09.660] result() for ClusterFuture ... done
[01:28:09.660] result() for ClusterFuture ...
[01:28:09.660] - result already collected: FutureResult
[01:28:09.660] result() for ClusterFuture ... done
[01:28:09.660] signalConditions() ...
[01:28:09.660]  - include = 'immediateCondition'
[01:28:09.661]  - exclude = 
[01:28:09.661]  - resignal = FALSE
[01:28:09.661]  - Number of conditions: 1
[01:28:09.661] signalConditions() ... done
[01:28:09.661] Future state: 'finished'
[01:28:09.662] result() for ClusterFuture ...
[01:28:09.662] - result already collected: FutureResult
[01:28:09.662] result() for ClusterFuture ... done
[01:28:09.662] signalConditions() ...
[01:28:09.662]  - include = 'condition'
[01:28:09.662]  - exclude = 'immediateCondition'
[01:28:09.663]  - resignal = TRUE
[01:28:09.663]  - Number of conditions: 1
[01:28:09.663]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:09.663] signalConditions() ... done
List of 1
 $ res: 'try-error' chr "Error in eval(quote({ : object 'a' not found\n"
  ..- attr(*, "condition")=List of 3
  .. ..$ message    : chr "object 'a' not found"
  .. ..$ call       : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. ..$ future.info:List of 5
  .. .. ..$ condition:List of 2
  .. .. .. ..$ message: chr "object 'a' not found"
  .. .. .. ..$ call   : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  .. .. ..$ calls    :List of 9
  .. .. .. ..$ : language res[[ii]] %<-% {     b <- a * ii ...
  .. .. .. ..$ : language futureAssignInternal(target, expr, envir = envir, substitute = FALSE)
  .. .. .. ..$ : language futureAssign(name, expr, envir = envir, assign.env = assign.env, substitute = FALSE)
  .. .. .. ..$ : language do.call(future::future, args = future.args, envir = assign.env)
  .. .. .. ..$ : language (function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE,      seed = FALSE, globals = TRUE, pack| __truncated__ ...
  .. .. .. ..$ : language Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, seed = seed,      globals = globals, packages = pack| __truncated__ ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..$ : language withCallingHandlers({     { ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. ..$ session  :List of 6
  .. .. .. ..$ r         :List of 15
  .. .. .. .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. .. .. .. ..$ arch          : chr "x86_64"
  .. .. .. .. ..$ os            : chr "mingw32"
  .. .. .. .. ..$ crt           : chr "ucrt"
  .. .. .. .. ..$ system        : chr "x86_64, mingw32"
  .. .. .. .. ..$ status        : chr "Under development (unstable)"
  .. .. .. .. ..$ major         : chr "4"
  .. .. .. .. ..$ minor         : chr "4.0"
  .. .. .. .. ..$ year          : chr "2023"
  .. .. .. .. ..$ month         : chr "12"
  .. .. .. .. ..$ day           : chr "20"
  .. .. .. .. ..$ svn rev       : chr "85713"
  .. .. .. .. ..$ language      : chr "R"
  .. .. .. .. ..$ version.string: chr "R Under development (unstable) (2023-12-20 r85713 ucrt)"
  .. .. .. .. ..$ nickname      : chr "Unsuffered Consequences"
  .. .. .. ..$ locale    : chr "LC_COLLATE=C;LC_CTYPE=German_Germany.utf8;LC_MONETARY=C;LC_NUMERIC=C;LC_TIME=C"
  .. .. .. ..$ rngkind   : chr [1:3] "Mersenne-Twister" "Inversion" "Rejection"
  .. .. .. ..$ namespaces: chr [1:16] "compiler" "parallelly" "graphics" "tools" ...
  .. .. .. ..$ search    : chr [1:9] ".GlobalEnv" "package:stats" "package:graphics" "package:grDevices" ...
  .. .. .. ..$ system    : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. .. ..$ timestamp: POSIXct[1:1], format: "2023-12-22 01:28:09"
  .. .. ..$ signaled : int 1
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.684] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.684] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.686] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:09.686] Searching for globals ... DONE
[01:28:09.686] Resolving globals: TRUE
[01:28:09.686] Resolving any globals that are futures ...
[01:28:09.686] - globals: [4] '{', '<-', '*', 'ii'
[01:28:09.687] Resolving any globals that are futures ... DONE
[01:28:09.687] Resolving futures part of globals (recursively) ...
[01:28:09.687] resolve() on list ...
[01:28:09.688]  recursive: 99
[01:28:09.688]  length: 1
[01:28:09.688]  elements: 'ii'
[01:28:09.688]  length: 0 (resolved future 1)
[01:28:09.688] resolve() on list ... DONE
[01:28:09.688] - globals: [1] 'ii'
[01:28:09.689] Resolving futures part of globals (recursively) ... DONE
[01:28:09.689] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:09.689] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:09.690] - globals: [1] 'ii'
[01:28:09.690] 
[01:28:09.690] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.691] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.691] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.693] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:09.693] Searching for globals ... DONE
[01:28:09.693] Resolving globals: TRUE
[01:28:09.693] Resolving any globals that are futures ...
[01:28:09.693] - globals: [4] '{', '<-', '*', 'ii'
[01:28:09.694] Resolving any globals that are futures ... DONE
[01:28:09.694] Resolving futures part of globals (recursively) ...
[01:28:09.694] resolve() on list ...
[01:28:09.694]  recursive: 99
[01:28:09.695]  length: 1
[01:28:09.695]  elements: 'ii'
[01:28:09.695]  length: 0 (resolved future 1)
[01:28:09.695] resolve() on list ... DONE
[01:28:09.695] - globals: [1] 'ii'
[01:28:09.695] Resolving futures part of globals (recursively) ... DONE
[01:28:09.696] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:09.696] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:09.696] - globals: [1] 'ii'
[01:28:09.697] 
[01:28:09.697] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.698] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.698] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.700] - globals found: [4] '{', '<-', '*', 'ii'
[01:28:09.700] Searching for globals ... DONE
[01:28:09.700] Resolving globals: TRUE
[01:28:09.700] Resolving any globals that are futures ...
[01:28:09.700] - globals: [4] '{', '<-', '*', 'ii'
[01:28:09.701] Resolving any globals that are futures ... DONE
[01:28:09.701] Resolving futures part of globals (recursively) ...
[01:28:09.701] resolve() on list ...
[01:28:09.702]  recursive: 99
[01:28:09.702]  length: 1
[01:28:09.702]  elements: 'ii'
[01:28:09.702]  length: 0 (resolved future 1)
[01:28:09.702] resolve() on list ... DONE
[01:28:09.702] - globals: [1] 'ii'
[01:28:09.703] Resolving futures part of globals (recursively) ... DONE
[01:28:09.703] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:09.703] The total size of the 1 globals exported for future expression ('{; b <- a * ii; a <- 0; b; }') 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:09.703] - globals: [1] 'ii'
[01:28:09.704] 
[01:28:09.704] getGlobalsAndPackages() ... DONE
[01:28:09.704] run() for 'Future' ...
[01:28:09.704] - state: 'created'
[01:28:09.705] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.719] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.719] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.720]   - Field: 'node'
[01:28:09.720]   - Field: 'label'
[01:28:09.720]   - Field: 'local'
[01:28:09.720]   - Field: 'owner'
[01:28:09.720]   - Field: 'envir'
[01:28:09.720]   - Field: 'workers'
[01:28:09.721]   - Field: 'packages'
[01:28:09.721]   - Field: 'gc'
[01:28:09.721]   - Field: 'conditions'
[01:28:09.721]   - Field: 'persistent'
[01:28:09.721]   - Field: 'expr'
[01:28:09.722]   - Field: 'uuid'
[01:28:09.722]   - Field: 'seed'
[01:28:09.722]   - Field: 'version'
[01:28:09.722]   - Field: 'result'
[01:28:09.722]   - Field: 'asynchronous'
[01:28:09.722]   - Field: 'calls'
[01:28:09.723]   - Field: 'globals'
[01:28:09.723]   - Field: 'stdout'
[01:28:09.723]   - Field: 'earlySignal'
[01:28:09.723]   - Field: 'lazy'
[01:28:09.723]   - Field: 'state'
[01:28:09.723] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.724] - Launch lazy future ...
[01:28:09.724] Packages needed by the future expression (n = 0): <none>
[01:28:09.724] Packages needed by future strategies (n = 0): <none>
[01:28:09.725] {
[01:28:09.725]     {
[01:28:09.725]         {
[01:28:09.725]             ...future.startTime <- base::Sys.time()
[01:28:09.725]             {
[01:28:09.725]                 {
[01:28:09.725]                   {
[01:28:09.725]                     {
[01:28:09.725]                       base::local({
[01:28:09.725]                         has_future <- base::requireNamespace("future", 
[01:28:09.725]                           quietly = TRUE)
[01:28:09.725]                         if (has_future) {
[01:28:09.725]                           ns <- base::getNamespace("future")
[01:28:09.725]                           version <- ns[[".package"]][["version"]]
[01:28:09.725]                           if (is.null(version)) 
[01:28:09.725]                             version <- utils::packageVersion("future")
[01:28:09.725]                         }
[01:28:09.725]                         else {
[01:28:09.725]                           version <- NULL
[01:28:09.725]                         }
[01:28:09.725]                         if (!has_future || version < "1.8.0") {
[01:28:09.725]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.725]                             "", base::R.version$version.string), 
[01:28:09.725]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.725]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.725]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.725]                               "release", "version")], collapse = " "), 
[01:28:09.725]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.725]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.725]                             info)
[01:28:09.725]                           info <- base::paste(info, collapse = "; ")
[01:28:09.725]                           if (!has_future) {
[01:28:09.725]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.725]                               info)
[01:28:09.725]                           }
[01:28:09.725]                           else {
[01:28:09.725]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.725]                               info, version)
[01:28:09.725]                           }
[01:28:09.725]                           base::stop(msg)
[01:28:09.725]                         }
[01:28:09.725]                       })
[01:28:09.725]                     }
[01:28:09.725]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.725]                     base::options(mc.cores = 1L)
[01:28:09.725]                   }
[01:28:09.725]                   options(future.plan = NULL)
[01:28:09.725]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.725]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.725]                 }
[01:28:09.725]                 ...future.workdir <- getwd()
[01:28:09.725]             }
[01:28:09.725]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.725]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.725]         }
[01:28:09.725]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.725]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.725]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.725]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.725]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.725]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.725]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.725]             base::names(...future.oldOptions))
[01:28:09.725]     }
[01:28:09.725]     if (FALSE) {
[01:28:09.725]     }
[01:28:09.725]     else {
[01:28:09.725]         if (TRUE) {
[01:28:09.725]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.725]                 open = "w")
[01:28:09.725]         }
[01:28:09.725]         else {
[01:28:09.725]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.725]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.725]         }
[01:28:09.725]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.725]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.725]             base::sink(type = "output", split = FALSE)
[01:28:09.725]             base::close(...future.stdout)
[01:28:09.725]         }, add = TRUE)
[01:28:09.725]     }
[01:28:09.725]     ...future.frame <- base::sys.nframe()
[01:28:09.725]     ...future.conditions <- base::list()
[01:28:09.725]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.725]     if (FALSE) {
[01:28:09.725]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.725]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.725]     }
[01:28:09.725]     ...future.result <- base::tryCatch({
[01:28:09.725]         base::withCallingHandlers({
[01:28:09.725]             ...future.value <- base::withVisible(base::local({
[01:28:09.725]                 ...future.makeSendCondition <- base::local({
[01:28:09.725]                   sendCondition <- NULL
[01:28:09.725]                   function(frame = 1L) {
[01:28:09.725]                     if (is.function(sendCondition)) 
[01:28:09.725]                       return(sendCondition)
[01:28:09.725]                     ns <- getNamespace("parallel")
[01:28:09.725]                     if (exists("sendData", mode = "function", 
[01:28:09.725]                       envir = ns)) {
[01:28:09.725]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.725]                         envir = ns)
[01:28:09.725]                       envir <- sys.frame(frame)
[01:28:09.725]                       master <- NULL
[01:28:09.725]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.725]                         !identical(envir, emptyenv())) {
[01:28:09.725]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.725]                           inherits = FALSE)) {
[01:28:09.725]                           master <- get("master", mode = "list", 
[01:28:09.725]                             envir = envir, inherits = FALSE)
[01:28:09.725]                           if (inherits(master, c("SOCKnode", 
[01:28:09.725]                             "SOCK0node"))) {
[01:28:09.725]                             sendCondition <<- function(cond) {
[01:28:09.725]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.725]                                 success = TRUE)
[01:28:09.725]                               parallel_sendData(master, data)
[01:28:09.725]                             }
[01:28:09.725]                             return(sendCondition)
[01:28:09.725]                           }
[01:28:09.725]                         }
[01:28:09.725]                         frame <- frame + 1L
[01:28:09.725]                         envir <- sys.frame(frame)
[01:28:09.725]                       }
[01:28:09.725]                     }
[01:28:09.725]                     sendCondition <<- function(cond) NULL
[01:28:09.725]                   }
[01:28:09.725]                 })
[01:28:09.725]                 withCallingHandlers({
[01:28:09.725]                   {
[01:28:09.725]                     b <- a * ii
[01:28:09.725]                     a <- 0
[01:28:09.725]                     b
[01:28:09.725]                   }
[01:28:09.725]                 }, immediateCondition = function(cond) {
[01:28:09.725]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.725]                   sendCondition(cond)
[01:28:09.725]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.725]                   {
[01:28:09.725]                     inherits <- base::inherits
[01:28:09.725]                     invokeRestart <- base::invokeRestart
[01:28:09.725]                     is.null <- base::is.null
[01:28:09.725]                     muffled <- FALSE
[01:28:09.725]                     if (inherits(cond, "message")) {
[01:28:09.725]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.725]                       if (muffled) 
[01:28:09.725]                         invokeRestart("muffleMessage")
[01:28:09.725]                     }
[01:28:09.725]                     else if (inherits(cond, "warning")) {
[01:28:09.725]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.725]                       if (muffled) 
[01:28:09.725]                         invokeRestart("muffleWarning")
[01:28:09.725]                     }
[01:28:09.725]                     else if (inherits(cond, "condition")) {
[01:28:09.725]                       if (!is.null(pattern)) {
[01:28:09.725]                         computeRestarts <- base::computeRestarts
[01:28:09.725]                         grepl <- base::grepl
[01:28:09.725]                         restarts <- computeRestarts(cond)
[01:28:09.725]                         for (restart in restarts) {
[01:28:09.725]                           name <- restart$name
[01:28:09.725]                           if (is.null(name)) 
[01:28:09.725]                             next
[01:28:09.725]                           if (!grepl(pattern, name)) 
[01:28:09.725]                             next
[01:28:09.725]                           invokeRestart(restart)
[01:28:09.725]                           muffled <- TRUE
[01:28:09.725]                           break
[01:28:09.725]                         }
[01:28:09.725]                       }
[01:28:09.725]                     }
[01:28:09.725]                     invisible(muffled)
[01:28:09.725]                   }
[01:28:09.725]                   muffleCondition(cond)
[01:28:09.725]                 })
[01:28:09.725]             }))
[01:28:09.725]             future::FutureResult(value = ...future.value$value, 
[01:28:09.725]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.725]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.725]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.725]                     ...future.globalenv.names))
[01:28:09.725]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.725]         }, condition = base::local({
[01:28:09.725]             c <- base::c
[01:28:09.725]             inherits <- base::inherits
[01:28:09.725]             invokeRestart <- base::invokeRestart
[01:28:09.725]             length <- base::length
[01:28:09.725]             list <- base::list
[01:28:09.725]             seq.int <- base::seq.int
[01:28:09.725]             signalCondition <- base::signalCondition
[01:28:09.725]             sys.calls <- base::sys.calls
[01:28:09.725]             `[[` <- base::`[[`
[01:28:09.725]             `+` <- base::`+`
[01:28:09.725]             `<<-` <- base::`<<-`
[01:28:09.725]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.725]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.725]                   3L)]
[01:28:09.725]             }
[01:28:09.725]             function(cond) {
[01:28:09.725]                 is_error <- inherits(cond, "error")
[01:28:09.725]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.725]                   NULL)
[01:28:09.725]                 if (is_error) {
[01:28:09.725]                   sessionInformation <- function() {
[01:28:09.725]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.725]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.725]                       search = base::search(), system = base::Sys.info())
[01:28:09.725]                   }
[01:28:09.725]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.725]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.725]                     cond$call), session = sessionInformation(), 
[01:28:09.725]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.725]                   signalCondition(cond)
[01:28:09.725]                 }
[01:28:09.725]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.725]                 "immediateCondition"))) {
[01:28:09.725]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.725]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.725]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.725]                   if (TRUE && !signal) {
[01:28:09.725]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.725]                     {
[01:28:09.725]                       inherits <- base::inherits
[01:28:09.725]                       invokeRestart <- base::invokeRestart
[01:28:09.725]                       is.null <- base::is.null
[01:28:09.725]                       muffled <- FALSE
[01:28:09.725]                       if (inherits(cond, "message")) {
[01:28:09.725]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.725]                         if (muffled) 
[01:28:09.725]                           invokeRestart("muffleMessage")
[01:28:09.725]                       }
[01:28:09.725]                       else if (inherits(cond, "warning")) {
[01:28:09.725]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.725]                         if (muffled) 
[01:28:09.725]                           invokeRestart("muffleWarning")
[01:28:09.725]                       }
[01:28:09.725]                       else if (inherits(cond, "condition")) {
[01:28:09.725]                         if (!is.null(pattern)) {
[01:28:09.725]                           computeRestarts <- base::computeRestarts
[01:28:09.725]                           grepl <- base::grepl
[01:28:09.725]                           restarts <- computeRestarts(cond)
[01:28:09.725]                           for (restart in restarts) {
[01:28:09.725]                             name <- restart$name
[01:28:09.725]                             if (is.null(name)) 
[01:28:09.725]                               next
[01:28:09.725]                             if (!grepl(pattern, name)) 
[01:28:09.725]                               next
[01:28:09.725]                             invokeRestart(restart)
[01:28:09.725]                             muffled <- TRUE
[01:28:09.725]                             break
[01:28:09.725]                           }
[01:28:09.725]                         }
[01:28:09.725]                       }
[01:28:09.725]                       invisible(muffled)
[01:28:09.725]                     }
[01:28:09.725]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.725]                   }
[01:28:09.725]                 }
[01:28:09.725]                 else {
[01:28:09.725]                   if (TRUE) {
[01:28:09.725]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.725]                     {
[01:28:09.725]                       inherits <- base::inherits
[01:28:09.725]                       invokeRestart <- base::invokeRestart
[01:28:09.725]                       is.null <- base::is.null
[01:28:09.725]                       muffled <- FALSE
[01:28:09.725]                       if (inherits(cond, "message")) {
[01:28:09.725]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.725]                         if (muffled) 
[01:28:09.725]                           invokeRestart("muffleMessage")
[01:28:09.725]                       }
[01:28:09.725]                       else if (inherits(cond, "warning")) {
[01:28:09.725]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.725]                         if (muffled) 
[01:28:09.725]                           invokeRestart("muffleWarning")
[01:28:09.725]                       }
[01:28:09.725]                       else if (inherits(cond, "condition")) {
[01:28:09.725]                         if (!is.null(pattern)) {
[01:28:09.725]                           computeRestarts <- base::computeRestarts
[01:28:09.725]                           grepl <- base::grepl
[01:28:09.725]                           restarts <- computeRestarts(cond)
[01:28:09.725]                           for (restart in restarts) {
[01:28:09.725]                             name <- restart$name
[01:28:09.725]                             if (is.null(name)) 
[01:28:09.725]                               next
[01:28:09.725]                             if (!grepl(pattern, name)) 
[01:28:09.725]                               next
[01:28:09.725]                             invokeRestart(restart)
[01:28:09.725]                             muffled <- TRUE
[01:28:09.725]                             break
[01:28:09.725]                           }
[01:28:09.725]                         }
[01:28:09.725]                       }
[01:28:09.725]                       invisible(muffled)
[01:28:09.725]                     }
[01:28:09.725]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.725]                   }
[01:28:09.725]                 }
[01:28:09.725]             }
[01:28:09.725]         }))
[01:28:09.725]     }, error = function(ex) {
[01:28:09.725]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.725]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.725]                 ...future.rng), started = ...future.startTime, 
[01:28:09.725]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.725]             version = "1.8"), class = "FutureResult")
[01:28:09.725]     }, finally = {
[01:28:09.725]         if (!identical(...future.workdir, getwd())) 
[01:28:09.725]             setwd(...future.workdir)
[01:28:09.725]         {
[01:28:09.725]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.725]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.725]             }
[01:28:09.725]             base::options(...future.oldOptions)
[01:28:09.725]             if (.Platform$OS.type == "windows") {
[01:28:09.725]                 old_names <- names(...future.oldEnvVars)
[01:28:09.725]                 envs <- base::Sys.getenv()
[01:28:09.725]                 names <- names(envs)
[01:28:09.725]                 common <- intersect(names, old_names)
[01:28:09.725]                 added <- setdiff(names, old_names)
[01:28:09.725]                 removed <- setdiff(old_names, names)
[01:28:09.725]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.725]                   envs[common]]
[01:28:09.725]                 NAMES <- toupper(changed)
[01:28:09.725]                 args <- list()
[01:28:09.725]                 for (kk in seq_along(NAMES)) {
[01:28:09.725]                   name <- changed[[kk]]
[01:28:09.725]                   NAME <- NAMES[[kk]]
[01:28:09.725]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.725]                     next
[01:28:09.725]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.725]                 }
[01:28:09.725]                 NAMES <- toupper(added)
[01:28:09.725]                 for (kk in seq_along(NAMES)) {
[01:28:09.725]                   name <- added[[kk]]
[01:28:09.725]                   NAME <- NAMES[[kk]]
[01:28:09.725]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.725]                     next
[01:28:09.725]                   args[[name]] <- ""
[01:28:09.725]                 }
[01:28:09.725]                 NAMES <- toupper(removed)
[01:28:09.725]                 for (kk in seq_along(NAMES)) {
[01:28:09.725]                   name <- removed[[kk]]
[01:28:09.725]                   NAME <- NAMES[[kk]]
[01:28:09.725]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.725]                     next
[01:28:09.725]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.725]                 }
[01:28:09.725]                 if (length(args) > 0) 
[01:28:09.725]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.725]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.725]             }
[01:28:09.725]             else {
[01:28:09.725]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.725]             }
[01:28:09.725]             {
[01:28:09.725]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.725]                   0L) {
[01:28:09.725]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.725]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.725]                   base::options(opts)
[01:28:09.725]                 }
[01:28:09.725]                 {
[01:28:09.725]                   {
[01:28:09.725]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.725]                     NULL
[01:28:09.725]                   }
[01:28:09.725]                   options(future.plan = NULL)
[01:28:09.725]                   if (is.na(NA_character_)) 
[01:28:09.725]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.725]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.725]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.725]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.725]                     envir = parent.frame()) 
[01:28:09.725]                   {
[01:28:09.725]                     if (is.function(workers)) 
[01:28:09.725]                       workers <- workers()
[01:28:09.725]                     workers <- structure(as.integer(workers), 
[01:28:09.725]                       class = class(workers))
[01:28:09.725]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.725]                       workers >= 1)
[01:28:09.725]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.725]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.725]                     }
[01:28:09.725]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.725]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.725]                       envir = envir)
[01:28:09.725]                     if (!future$lazy) 
[01:28:09.725]                       future <- run(future)
[01:28:09.725]                     invisible(future)
[01:28:09.725]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.725]                 }
[01:28:09.725]             }
[01:28:09.725]         }
[01:28:09.725]     })
[01:28:09.725]     if (TRUE) {
[01:28:09.725]         base::sink(type = "output", split = FALSE)
[01:28:09.725]         if (TRUE) {
[01:28:09.725]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.725]         }
[01:28:09.725]         else {
[01:28:09.725]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.725]         }
[01:28:09.725]         base::close(...future.stdout)
[01:28:09.725]         ...future.stdout <- NULL
[01:28:09.725]     }
[01:28:09.725]     ...future.result$conditions <- ...future.conditions
[01:28:09.725]     ...future.result$finished <- base::Sys.time()
[01:28:09.725]     ...future.result
[01:28:09.725] }
[01:28:09.730] Poll #1 (0): usedNodes() = 2, workers = 2
[01:28:09.758] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.758] - Validating connection of MultisessionFuture
[01:28:09.759] - received message: FutureResult
[01:28:09.760] - Received FutureResult
[01:28:09.760] - Erased future from FutureRegistry
[01:28:09.761] result() for ClusterFuture ...
[01:28:09.761] - result already collected: FutureResult
[01:28:09.761] result() for ClusterFuture ... done
[01:28:09.761] signalConditions() ...
[01:28:09.761]  - include = 'immediateCondition'
[01:28:09.761]  - exclude = 
[01:28:09.762]  - resignal = FALSE
[01:28:09.762]  - Number of conditions: 1
[01:28:09.762] signalConditions() ... done
[01:28:09.762] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.762] result() for ClusterFuture ...
[01:28:09.763] - result already collected: FutureResult
[01:28:09.763] result() for ClusterFuture ... done
[01:28:09.763] result() for ClusterFuture ...
[01:28:09.763] - result already collected: FutureResult
[01:28:09.763] result() for ClusterFuture ... done
[01:28:09.763] signalConditions() ...
[01:28:09.764]  - include = 'immediateCondition'
[01:28:09.764]  - exclude = 
[01:28:09.764]  - resignal = FALSE
[01:28:09.764]  - Number of conditions: 1
[01:28:09.764] signalConditions() ... done
[01:28:09.765] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[01:28:09.766] Exporting 'ii' (56 bytes) to cluster node #2 ...
[01:28:09.766] Exporting 'ii' (56 bytes) to cluster node #2 ... DONE
[01:28:09.766] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[01:28:09.767] MultisessionFuture started
[01:28:09.767] - Launch lazy future ... done
[01:28:09.767] run() for 'MultisessionFuture' ... done
[01:28:09.767] result() for ClusterFuture ...
[01:28:09.768] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.768] - Validating connection of MultisessionFuture
[01:28:09.787] - received message: FutureResult
[01:28:09.788] - Received FutureResult
[01:28:09.788] - Erased future from FutureRegistry
[01:28:09.788] result() for ClusterFuture ...
[01:28:09.788] - result already collected: FutureResult
[01:28:09.788] result() for ClusterFuture ... done
[01:28:09.789] signalConditions() ...
[01:28:09.789]  - include = 'immediateCondition'
[01:28:09.789]  - exclude = 
[01:28:09.789]  - resignal = FALSE
[01:28:09.789]  - Number of conditions: 1
[01:28:09.789] signalConditions() ... done
[01:28:09.790] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.790] result() for ClusterFuture ... done
[01:28:09.790] result() for ClusterFuture ...
[01:28:09.790] - result already collected: FutureResult
[01:28:09.790] result() for ClusterFuture ... done
[01:28:09.790] signalConditions() ...
[01:28:09.791]  - include = 'immediateCondition'
[01:28:09.791]  - exclude = 
[01:28:09.791]  - resignal = FALSE
[01:28:09.791]  - Number of conditions: 1
[01:28:09.791] signalConditions() ... done
[01:28:09.792] Future state: 'finished'
[01:28:09.793] result() for ClusterFuture ...
[01:28:09.793] - result already collected: FutureResult
[01:28:09.794] result() for ClusterFuture ... done
[01:28:09.794] signalConditions() ...
[01:28:09.794]  - include = 'condition'
[01:28:09.795]  - exclude = 'immediateCondition'
[01:28:09.795]  - resignal = TRUE
[01:28:09.795]  - Number of conditions: 1
[01:28:09.796]  - Condition #1: 'simpleError', 'error', 'condition'
[01:28:09.796] signalConditions() ... done
List of 1
 $ res: 'try-error' chr "Error in eval(quote({ : object 'a' not found\n"
  ..- attr(*, "condition")=List of 3
  .. ..$ message    : chr "object 'a' not found"
  .. ..$ call       : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. ..$ future.info:List of 5
  .. .. ..$ condition:List of 2
  .. .. .. ..$ message: chr "object 'a' not found"
  .. .. .. ..$ call   : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  .. .. ..$ calls    :List of 12
  .. .. .. ..$ : language res[[ii]] %<-% {     b <- a * ii ...
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language eval(fassignment, envir = envir, enclos = baseenv())
  .. .. .. ..$ : language res[[ii]] %<-% {     b <- a * ii ...
  .. .. .. ..$ : language futureAssignInternal(target, expr, envir = envir, substitute = FALSE)
  .. .. .. ..$ : language futureAssign(name, expr, envir = envir, assign.env = assign.env, substitute = FALSE)
  .. .. .. ..$ : language do.call(future::future, args = future.args, envir = assign.env)
  .. .. .. ..$ : language (function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE,      seed = FALSE, globals = TRUE, pack| __truncated__ ...
  .. .. .. ..$ : language Future(expr, substitute = FALSE, envir = envir, lazy = TRUE, seed = seed,      globals = globals, packages = pack| __truncated__ ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. .. ..$ : language withCallingHandlers({     { ...
  .. .. .. ..$ : language eval(quote({     ...future.makeSendCondition <- base::local({ ...
  .. .. ..$ session  :List of 6
  .. .. .. ..$ r         :List of 15
  .. .. .. .. ..$ platform      : chr "x86_64-w64-mingw32"
  .. .. .. .. ..$ arch          : chr "x86_64"
  .. .. .. .. ..$ os            : chr "mingw32"
  .. .. .. .. ..$ crt           : chr "ucrt"
  .. .. .. .. ..$ system        : chr "x86_64, mingw32"
  .. .. .. .. ..$ status        : chr "Under development (unstable)"
  .. .. .. .. ..$ major         : chr "4"
  .. .. .. .. ..$ minor         : chr "4.0"
  .. .. .. .. ..$ year          : chr "2023"
  .. .. .. .. ..$ month         : chr "12"
  .. .. .. .. ..$ day           : chr "20"
  .. .. .. .. ..$ svn rev       : chr "85713"
  .. .. .. .. ..$ language      : chr "R"
  .. .. .. .. ..$ version.string: chr "R Under development (unstable) (2023-12-20 r85713 ucrt)"
  .. .. .. .. ..$ nickname      : chr "Unsuffered Consequences"
  .. .. .. ..$ locale    : chr "LC_COLLATE=C;LC_CTYPE=German_Germany.utf8;LC_MONETARY=C;LC_NUMERIC=C;LC_TIME=C"
  .. .. .. ..$ rngkind   : chr [1:3] "Mersenne-Twister" "Inversion" "Rejection"
  .. .. .. ..$ namespaces: chr [1:16] "compiler" "parallelly" "graphics" "tools" ...
  .. .. .. ..$ search    : chr [1:9] ".GlobalEnv" "package:stats" "package:graphics" "package:grDevices" ...
  .. .. .. ..$ system    : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...
  .. .. .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...
  .. .. ..$ timestamp: POSIXct[1:1], format: "2023-12-22 01:28:09"
  .. .. ..$ signaled : int 1
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.822] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.822] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.823] 
[01:28:09.824] Searching for globals ... DONE
[01:28:09.824] - globals: [0] <none>
[01:28:09.824] getGlobalsAndPackages() ... DONE
[01:28:09.825] run() for 'Future' ...
[01:28:09.825] - state: 'created'
[01:28:09.825] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.842] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.842] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.842]   - Field: 'node'
[01:28:09.842]   - Field: 'label'
[01:28:09.843]   - Field: 'local'
[01:28:09.843]   - Field: 'owner'
[01:28:09.843]   - Field: 'envir'
[01:28:09.843]   - Field: 'workers'
[01:28:09.843]   - Field: 'packages'
[01:28:09.844]   - Field: 'gc'
[01:28:09.844]   - Field: 'conditions'
[01:28:09.844]   - Field: 'persistent'
[01:28:09.844]   - Field: 'expr'
[01:28:09.844]   - Field: 'uuid'
[01:28:09.845]   - Field: 'seed'
[01:28:09.845]   - Field: 'version'
[01:28:09.845]   - Field: 'result'
[01:28:09.845]   - Field: 'asynchronous'
[01:28:09.845]   - Field: 'calls'
[01:28:09.846]   - Field: 'globals'
[01:28:09.846]   - Field: 'stdout'
[01:28:09.846]   - Field: 'earlySignal'
[01:28:09.846]   - Field: 'lazy'
[01:28:09.846]   - Field: 'state'
[01:28:09.847] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.847] - Launch lazy future ...
[01:28:09.847] Packages needed by the future expression (n = 0): <none>
[01:28:09.847] Packages needed by future strategies (n = 0): <none>
[01:28:09.848] {
[01:28:09.848]     {
[01:28:09.848]         {
[01:28:09.848]             ...future.startTime <- base::Sys.time()
[01:28:09.848]             {
[01:28:09.848]                 {
[01:28:09.848]                   {
[01:28:09.848]                     {
[01:28:09.848]                       base::local({
[01:28:09.848]                         has_future <- base::requireNamespace("future", 
[01:28:09.848]                           quietly = TRUE)
[01:28:09.848]                         if (has_future) {
[01:28:09.848]                           ns <- base::getNamespace("future")
[01:28:09.848]                           version <- ns[[".package"]][["version"]]
[01:28:09.848]                           if (is.null(version)) 
[01:28:09.848]                             version <- utils::packageVersion("future")
[01:28:09.848]                         }
[01:28:09.848]                         else {
[01:28:09.848]                           version <- NULL
[01:28:09.848]                         }
[01:28:09.848]                         if (!has_future || version < "1.8.0") {
[01:28:09.848]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.848]                             "", base::R.version$version.string), 
[01:28:09.848]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.848]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.848]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.848]                               "release", "version")], collapse = " "), 
[01:28:09.848]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.848]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.848]                             info)
[01:28:09.848]                           info <- base::paste(info, collapse = "; ")
[01:28:09.848]                           if (!has_future) {
[01:28:09.848]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.848]                               info)
[01:28:09.848]                           }
[01:28:09.848]                           else {
[01:28:09.848]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.848]                               info, version)
[01:28:09.848]                           }
[01:28:09.848]                           base::stop(msg)
[01:28:09.848]                         }
[01:28:09.848]                       })
[01:28:09.848]                     }
[01:28:09.848]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.848]                     base::options(mc.cores = 1L)
[01:28:09.848]                   }
[01:28:09.848]                   options(future.plan = NULL)
[01:28:09.848]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.848]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.848]                 }
[01:28:09.848]                 ...future.workdir <- getwd()
[01:28:09.848]             }
[01:28:09.848]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.848]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.848]         }
[01:28:09.848]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.848]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.848]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.848]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.848]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.848]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.848]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.848]             base::names(...future.oldOptions))
[01:28:09.848]     }
[01:28:09.848]     if (FALSE) {
[01:28:09.848]     }
[01:28:09.848]     else {
[01:28:09.848]         if (TRUE) {
[01:28:09.848]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.848]                 open = "w")
[01:28:09.848]         }
[01:28:09.848]         else {
[01:28:09.848]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.848]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.848]         }
[01:28:09.848]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.848]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.848]             base::sink(type = "output", split = FALSE)
[01:28:09.848]             base::close(...future.stdout)
[01:28:09.848]         }, add = TRUE)
[01:28:09.848]     }
[01:28:09.848]     ...future.frame <- base::sys.nframe()
[01:28:09.848]     ...future.conditions <- base::list()
[01:28:09.848]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.848]     if (FALSE) {
[01:28:09.848]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.848]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.848]     }
[01:28:09.848]     ...future.result <- base::tryCatch({
[01:28:09.848]         base::withCallingHandlers({
[01:28:09.848]             ...future.value <- base::withVisible(base::local({
[01:28:09.848]                 ...future.makeSendCondition <- base::local({
[01:28:09.848]                   sendCondition <- NULL
[01:28:09.848]                   function(frame = 1L) {
[01:28:09.848]                     if (is.function(sendCondition)) 
[01:28:09.848]                       return(sendCondition)
[01:28:09.848]                     ns <- getNamespace("parallel")
[01:28:09.848]                     if (exists("sendData", mode = "function", 
[01:28:09.848]                       envir = ns)) {
[01:28:09.848]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.848]                         envir = ns)
[01:28:09.848]                       envir <- sys.frame(frame)
[01:28:09.848]                       master <- NULL
[01:28:09.848]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.848]                         !identical(envir, emptyenv())) {
[01:28:09.848]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.848]                           inherits = FALSE)) {
[01:28:09.848]                           master <- get("master", mode = "list", 
[01:28:09.848]                             envir = envir, inherits = FALSE)
[01:28:09.848]                           if (inherits(master, c("SOCKnode", 
[01:28:09.848]                             "SOCK0node"))) {
[01:28:09.848]                             sendCondition <<- function(cond) {
[01:28:09.848]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.848]                                 success = TRUE)
[01:28:09.848]                               parallel_sendData(master, data)
[01:28:09.848]                             }
[01:28:09.848]                             return(sendCondition)
[01:28:09.848]                           }
[01:28:09.848]                         }
[01:28:09.848]                         frame <- frame + 1L
[01:28:09.848]                         envir <- sys.frame(frame)
[01:28:09.848]                       }
[01:28:09.848]                     }
[01:28:09.848]                     sendCondition <<- function(cond) NULL
[01:28:09.848]                   }
[01:28:09.848]                 })
[01:28:09.848]                 withCallingHandlers({
[01:28:09.848]                   1
[01:28:09.848]                 }, immediateCondition = function(cond) {
[01:28:09.848]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.848]                   sendCondition(cond)
[01:28:09.848]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.848]                   {
[01:28:09.848]                     inherits <- base::inherits
[01:28:09.848]                     invokeRestart <- base::invokeRestart
[01:28:09.848]                     is.null <- base::is.null
[01:28:09.848]                     muffled <- FALSE
[01:28:09.848]                     if (inherits(cond, "message")) {
[01:28:09.848]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.848]                       if (muffled) 
[01:28:09.848]                         invokeRestart("muffleMessage")
[01:28:09.848]                     }
[01:28:09.848]                     else if (inherits(cond, "warning")) {
[01:28:09.848]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.848]                       if (muffled) 
[01:28:09.848]                         invokeRestart("muffleWarning")
[01:28:09.848]                     }
[01:28:09.848]                     else if (inherits(cond, "condition")) {
[01:28:09.848]                       if (!is.null(pattern)) {
[01:28:09.848]                         computeRestarts <- base::computeRestarts
[01:28:09.848]                         grepl <- base::grepl
[01:28:09.848]                         restarts <- computeRestarts(cond)
[01:28:09.848]                         for (restart in restarts) {
[01:28:09.848]                           name <- restart$name
[01:28:09.848]                           if (is.null(name)) 
[01:28:09.848]                             next
[01:28:09.848]                           if (!grepl(pattern, name)) 
[01:28:09.848]                             next
[01:28:09.848]                           invokeRestart(restart)
[01:28:09.848]                           muffled <- TRUE
[01:28:09.848]                           break
[01:28:09.848]                         }
[01:28:09.848]                       }
[01:28:09.848]                     }
[01:28:09.848]                     invisible(muffled)
[01:28:09.848]                   }
[01:28:09.848]                   muffleCondition(cond)
[01:28:09.848]                 })
[01:28:09.848]             }))
[01:28:09.848]             future::FutureResult(value = ...future.value$value, 
[01:28:09.848]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.848]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.848]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.848]                     ...future.globalenv.names))
[01:28:09.848]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.848]         }, condition = base::local({
[01:28:09.848]             c <- base::c
[01:28:09.848]             inherits <- base::inherits
[01:28:09.848]             invokeRestart <- base::invokeRestart
[01:28:09.848]             length <- base::length
[01:28:09.848]             list <- base::list
[01:28:09.848]             seq.int <- base::seq.int
[01:28:09.848]             signalCondition <- base::signalCondition
[01:28:09.848]             sys.calls <- base::sys.calls
[01:28:09.848]             `[[` <- base::`[[`
[01:28:09.848]             `+` <- base::`+`
[01:28:09.848]             `<<-` <- base::`<<-`
[01:28:09.848]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.848]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.848]                   3L)]
[01:28:09.848]             }
[01:28:09.848]             function(cond) {
[01:28:09.848]                 is_error <- inherits(cond, "error")
[01:28:09.848]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.848]                   NULL)
[01:28:09.848]                 if (is_error) {
[01:28:09.848]                   sessionInformation <- function() {
[01:28:09.848]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.848]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.848]                       search = base::search(), system = base::Sys.info())
[01:28:09.848]                   }
[01:28:09.848]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.848]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.848]                     cond$call), session = sessionInformation(), 
[01:28:09.848]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.848]                   signalCondition(cond)
[01:28:09.848]                 }
[01:28:09.848]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.848]                 "immediateCondition"))) {
[01:28:09.848]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.848]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.848]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.848]                   if (TRUE && !signal) {
[01:28:09.848]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.848]                     {
[01:28:09.848]                       inherits <- base::inherits
[01:28:09.848]                       invokeRestart <- base::invokeRestart
[01:28:09.848]                       is.null <- base::is.null
[01:28:09.848]                       muffled <- FALSE
[01:28:09.848]                       if (inherits(cond, "message")) {
[01:28:09.848]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.848]                         if (muffled) 
[01:28:09.848]                           invokeRestart("muffleMessage")
[01:28:09.848]                       }
[01:28:09.848]                       else if (inherits(cond, "warning")) {
[01:28:09.848]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.848]                         if (muffled) 
[01:28:09.848]                           invokeRestart("muffleWarning")
[01:28:09.848]                       }
[01:28:09.848]                       else if (inherits(cond, "condition")) {
[01:28:09.848]                         if (!is.null(pattern)) {
[01:28:09.848]                           computeRestarts <- base::computeRestarts
[01:28:09.848]                           grepl <- base::grepl
[01:28:09.848]                           restarts <- computeRestarts(cond)
[01:28:09.848]                           for (restart in restarts) {
[01:28:09.848]                             name <- restart$name
[01:28:09.848]                             if (is.null(name)) 
[01:28:09.848]                               next
[01:28:09.848]                             if (!grepl(pattern, name)) 
[01:28:09.848]                               next
[01:28:09.848]                             invokeRestart(restart)
[01:28:09.848]                             muffled <- TRUE
[01:28:09.848]                             break
[01:28:09.848]                           }
[01:28:09.848]                         }
[01:28:09.848]                       }
[01:28:09.848]                       invisible(muffled)
[01:28:09.848]                     }
[01:28:09.848]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.848]                   }
[01:28:09.848]                 }
[01:28:09.848]                 else {
[01:28:09.848]                   if (TRUE) {
[01:28:09.848]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.848]                     {
[01:28:09.848]                       inherits <- base::inherits
[01:28:09.848]                       invokeRestart <- base::invokeRestart
[01:28:09.848]                       is.null <- base::is.null
[01:28:09.848]                       muffled <- FALSE
[01:28:09.848]                       if (inherits(cond, "message")) {
[01:28:09.848]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.848]                         if (muffled) 
[01:28:09.848]                           invokeRestart("muffleMessage")
[01:28:09.848]                       }
[01:28:09.848]                       else if (inherits(cond, "warning")) {
[01:28:09.848]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.848]                         if (muffled) 
[01:28:09.848]                           invokeRestart("muffleWarning")
[01:28:09.848]                       }
[01:28:09.848]                       else if (inherits(cond, "condition")) {
[01:28:09.848]                         if (!is.null(pattern)) {
[01:28:09.848]                           computeRestarts <- base::computeRestarts
[01:28:09.848]                           grepl <- base::grepl
[01:28:09.848]                           restarts <- computeRestarts(cond)
[01:28:09.848]                           for (restart in restarts) {
[01:28:09.848]                             name <- restart$name
[01:28:09.848]                             if (is.null(name)) 
[01:28:09.848]                               next
[01:28:09.848]                             if (!grepl(pattern, name)) 
[01:28:09.848]                               next
[01:28:09.848]                             invokeRestart(restart)
[01:28:09.848]                             muffled <- TRUE
[01:28:09.848]                             break
[01:28:09.848]                           }
[01:28:09.848]                         }
[01:28:09.848]                       }
[01:28:09.848]                       invisible(muffled)
[01:28:09.848]                     }
[01:28:09.848]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.848]                   }
[01:28:09.848]                 }
[01:28:09.848]             }
[01:28:09.848]         }))
[01:28:09.848]     }, error = function(ex) {
[01:28:09.848]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.848]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.848]                 ...future.rng), started = ...future.startTime, 
[01:28:09.848]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.848]             version = "1.8"), class = "FutureResult")
[01:28:09.848]     }, finally = {
[01:28:09.848]         if (!identical(...future.workdir, getwd())) 
[01:28:09.848]             setwd(...future.workdir)
[01:28:09.848]         {
[01:28:09.848]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.848]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.848]             }
[01:28:09.848]             base::options(...future.oldOptions)
[01:28:09.848]             if (.Platform$OS.type == "windows") {
[01:28:09.848]                 old_names <- names(...future.oldEnvVars)
[01:28:09.848]                 envs <- base::Sys.getenv()
[01:28:09.848]                 names <- names(envs)
[01:28:09.848]                 common <- intersect(names, old_names)
[01:28:09.848]                 added <- setdiff(names, old_names)
[01:28:09.848]                 removed <- setdiff(old_names, names)
[01:28:09.848]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.848]                   envs[common]]
[01:28:09.848]                 NAMES <- toupper(changed)
[01:28:09.848]                 args <- list()
[01:28:09.848]                 for (kk in seq_along(NAMES)) {
[01:28:09.848]                   name <- changed[[kk]]
[01:28:09.848]                   NAME <- NAMES[[kk]]
[01:28:09.848]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.848]                     next
[01:28:09.848]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.848]                 }
[01:28:09.848]                 NAMES <- toupper(added)
[01:28:09.848]                 for (kk in seq_along(NAMES)) {
[01:28:09.848]                   name <- added[[kk]]
[01:28:09.848]                   NAME <- NAMES[[kk]]
[01:28:09.848]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.848]                     next
[01:28:09.848]                   args[[name]] <- ""
[01:28:09.848]                 }
[01:28:09.848]                 NAMES <- toupper(removed)
[01:28:09.848]                 for (kk in seq_along(NAMES)) {
[01:28:09.848]                   name <- removed[[kk]]
[01:28:09.848]                   NAME <- NAMES[[kk]]
[01:28:09.848]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.848]                     next
[01:28:09.848]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.848]                 }
[01:28:09.848]                 if (length(args) > 0) 
[01:28:09.848]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.848]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.848]             }
[01:28:09.848]             else {
[01:28:09.848]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.848]             }
[01:28:09.848]             {
[01:28:09.848]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.848]                   0L) {
[01:28:09.848]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.848]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.848]                   base::options(opts)
[01:28:09.848]                 }
[01:28:09.848]                 {
[01:28:09.848]                   {
[01:28:09.848]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.848]                     NULL
[01:28:09.848]                   }
[01:28:09.848]                   options(future.plan = NULL)
[01:28:09.848]                   if (is.na(NA_character_)) 
[01:28:09.848]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.848]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.848]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.848]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.848]                     envir = parent.frame()) 
[01:28:09.848]                   {
[01:28:09.848]                     if (is.function(workers)) 
[01:28:09.848]                       workers <- workers()
[01:28:09.848]                     workers <- structure(as.integer(workers), 
[01:28:09.848]                       class = class(workers))
[01:28:09.848]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.848]                       workers >= 1)
[01:28:09.848]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.848]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.848]                     }
[01:28:09.848]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.848]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.848]                       envir = envir)
[01:28:09.848]                     if (!future$lazy) 
[01:28:09.848]                       future <- run(future)
[01:28:09.848]                     invisible(future)
[01:28:09.848]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.848]                 }
[01:28:09.848]             }
[01:28:09.848]         }
[01:28:09.848]     })
[01:28:09.848]     if (TRUE) {
[01:28:09.848]         base::sink(type = "output", split = FALSE)
[01:28:09.848]         if (TRUE) {
[01:28:09.848]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.848]         }
[01:28:09.848]         else {
[01:28:09.848]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.848]         }
[01:28:09.848]         base::close(...future.stdout)
[01:28:09.848]         ...future.stdout <- NULL
[01:28:09.848]     }
[01:28:09.848]     ...future.result$conditions <- ...future.conditions
[01:28:09.848]     ...future.result$finished <- base::Sys.time()
[01:28:09.848]     ...future.result
[01:28:09.848] }
[01:28:09.856] MultisessionFuture started
[01:28:09.856] - Launch lazy future ... done
[01:28:09.856] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.857] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.857] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.859] - globals found: [3] '+', 'value', 'a'
[01:28:09.863] Searching for globals ... DONE
[01:28:09.864] Resolving globals: TRUE
[01:28:09.864] Resolving any globals that are futures ...
[01:28:09.864] - globals: [3] '+', 'value', 'a'
[01:28:09.864] Resolving any globals that are futures ... DONE
[01:28:09.865] Resolving futures part of globals (recursively) ...
[01:28:09.865] resolve() on list ...
[01:28:09.865]  recursive: 99
[01:28:09.865]  length: 1
[01:28:09.865]  elements: 'a'
[01:28:09.875] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.875] - Validating connection of MultisessionFuture
[01:28:09.876] - received message: FutureResult
[01:28:09.876] - Received FutureResult
[01:28:09.876] - Erased future from FutureRegistry
[01:28:09.876] result() for ClusterFuture ...
[01:28:09.877] - result already collected: FutureResult
[01:28:09.877] result() for ClusterFuture ... done
[01:28:09.877] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.877] Future #1
[01:28:09.877] result() for ClusterFuture ...
[01:28:09.877] - result already collected: FutureResult
[01:28:09.877] result() for ClusterFuture ... done
[01:28:09.878] result() for ClusterFuture ...
[01:28:09.878] - result already collected: FutureResult
[01:28:09.878] result() for ClusterFuture ... done
[01:28:09.878] A MultisessionFuture was resolved
[01:28:09.879]  length: 0 (resolved future 1)
[01:28:09.879] resolve() on list ... DONE
[01:28:09.879] - globals: [1] 'a'
[01:28:09.879] Resolving futures part of globals (recursively) ... DONE
[01:28:09.881] The total size of the 1 globals is 10.05 KiB (10296 bytes)
[01:28:09.881] The total size of the 1 globals exported for future expression ('value(a) + 1') is 10.05 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (10.05 KiB of class 'environment')
[01:28:09.881] - globals: [1] 'a'
[01:28:09.882] - packages: [1] 'future'
[01:28:09.882] getGlobalsAndPackages() ... DONE
[01:28:09.882] run() for 'Future' ...
[01:28:09.883] - state: 'created'
[01:28:09.883] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.899] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.899] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.900]   - Field: 'node'
[01:28:09.900]   - Field: 'label'
[01:28:09.900]   - Field: 'local'
[01:28:09.900]   - Field: 'owner'
[01:28:09.900]   - Field: 'envir'
[01:28:09.901]   - Field: 'workers'
[01:28:09.901]   - Field: 'packages'
[01:28:09.901]   - Field: 'gc'
[01:28:09.901]   - Field: 'conditions'
[01:28:09.901]   - Field: 'persistent'
[01:28:09.902]   - Field: 'expr'
[01:28:09.902]   - Field: 'uuid'
[01:28:09.902]   - Field: 'seed'
[01:28:09.902]   - Field: 'version'
[01:28:09.902]   - Field: 'result'
[01:28:09.903]   - Field: 'asynchronous'
[01:28:09.903]   - Field: 'calls'
[01:28:09.903]   - Field: 'globals'
[01:28:09.903]   - Field: 'stdout'
[01:28:09.904]   - Field: 'earlySignal'
[01:28:09.904]   - Field: 'lazy'
[01:28:09.904]   - Field: 'state'
[01:28:09.904] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.904] - Launch lazy future ...
[01:28:09.905] Packages needed by the future expression (n = 1): 'future'
[01:28:09.905] Packages needed by future strategies (n = 0): <none>
[01:28:09.906] {
[01:28:09.906]     {
[01:28:09.906]         {
[01:28:09.906]             ...future.startTime <- base::Sys.time()
[01:28:09.906]             {
[01:28:09.906]                 {
[01:28:09.906]                   {
[01:28:09.906]                     {
[01:28:09.906]                       {
[01:28:09.906]                         base::local({
[01:28:09.906]                           has_future <- base::requireNamespace("future", 
[01:28:09.906]                             quietly = TRUE)
[01:28:09.906]                           if (has_future) {
[01:28:09.906]                             ns <- base::getNamespace("future")
[01:28:09.906]                             version <- ns[[".package"]][["version"]]
[01:28:09.906]                             if (is.null(version)) 
[01:28:09.906]                               version <- utils::packageVersion("future")
[01:28:09.906]                           }
[01:28:09.906]                           else {
[01:28:09.906]                             version <- NULL
[01:28:09.906]                           }
[01:28:09.906]                           if (!has_future || version < "1.8.0") {
[01:28:09.906]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.906]                               "", base::R.version$version.string), 
[01:28:09.906]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:09.906]                                 base::R.version$platform, 8 * 
[01:28:09.906]                                   base::.Machine$sizeof.pointer), 
[01:28:09.906]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.906]                                 "release", "version")], collapse = " "), 
[01:28:09.906]                               hostname = base::Sys.info()[["nodename"]])
[01:28:09.906]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.906]                               info)
[01:28:09.906]                             info <- base::paste(info, collapse = "; ")
[01:28:09.906]                             if (!has_future) {
[01:28:09.906]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.906]                                 info)
[01:28:09.906]                             }
[01:28:09.906]                             else {
[01:28:09.906]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.906]                                 info, version)
[01:28:09.906]                             }
[01:28:09.906]                             base::stop(msg)
[01:28:09.906]                           }
[01:28:09.906]                         })
[01:28:09.906]                       }
[01:28:09.906]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.906]                       base::options(mc.cores = 1L)
[01:28:09.906]                     }
[01:28:09.906]                     base::local({
[01:28:09.906]                       for (pkg in "future") {
[01:28:09.906]                         base::loadNamespace(pkg)
[01:28:09.906]                         base::library(pkg, character.only = TRUE)
[01:28:09.906]                       }
[01:28:09.906]                     })
[01:28:09.906]                   }
[01:28:09.906]                   options(future.plan = NULL)
[01:28:09.906]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.906]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.906]                 }
[01:28:09.906]                 ...future.workdir <- getwd()
[01:28:09.906]             }
[01:28:09.906]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.906]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.906]         }
[01:28:09.906]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.906]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.906]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.906]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.906]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.906]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.906]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.906]             base::names(...future.oldOptions))
[01:28:09.906]     }
[01:28:09.906]     if (FALSE) {
[01:28:09.906]     }
[01:28:09.906]     else {
[01:28:09.906]         if (TRUE) {
[01:28:09.906]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.906]                 open = "w")
[01:28:09.906]         }
[01:28:09.906]         else {
[01:28:09.906]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.906]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.906]         }
[01:28:09.906]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.906]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.906]             base::sink(type = "output", split = FALSE)
[01:28:09.906]             base::close(...future.stdout)
[01:28:09.906]         }, add = TRUE)
[01:28:09.906]     }
[01:28:09.906]     ...future.frame <- base::sys.nframe()
[01:28:09.906]     ...future.conditions <- base::list()
[01:28:09.906]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.906]     if (FALSE) {
[01:28:09.906]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.906]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.906]     }
[01:28:09.906]     ...future.result <- base::tryCatch({
[01:28:09.906]         base::withCallingHandlers({
[01:28:09.906]             ...future.value <- base::withVisible(base::local({
[01:28:09.906]                 ...future.makeSendCondition <- base::local({
[01:28:09.906]                   sendCondition <- NULL
[01:28:09.906]                   function(frame = 1L) {
[01:28:09.906]                     if (is.function(sendCondition)) 
[01:28:09.906]                       return(sendCondition)
[01:28:09.906]                     ns <- getNamespace("parallel")
[01:28:09.906]                     if (exists("sendData", mode = "function", 
[01:28:09.906]                       envir = ns)) {
[01:28:09.906]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.906]                         envir = ns)
[01:28:09.906]                       envir <- sys.frame(frame)
[01:28:09.906]                       master <- NULL
[01:28:09.906]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.906]                         !identical(envir, emptyenv())) {
[01:28:09.906]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.906]                           inherits = FALSE)) {
[01:28:09.906]                           master <- get("master", mode = "list", 
[01:28:09.906]                             envir = envir, inherits = FALSE)
[01:28:09.906]                           if (inherits(master, c("SOCKnode", 
[01:28:09.906]                             "SOCK0node"))) {
[01:28:09.906]                             sendCondition <<- function(cond) {
[01:28:09.906]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.906]                                 success = TRUE)
[01:28:09.906]                               parallel_sendData(master, data)
[01:28:09.906]                             }
[01:28:09.906]                             return(sendCondition)
[01:28:09.906]                           }
[01:28:09.906]                         }
[01:28:09.906]                         frame <- frame + 1L
[01:28:09.906]                         envir <- sys.frame(frame)
[01:28:09.906]                       }
[01:28:09.906]                     }
[01:28:09.906]                     sendCondition <<- function(cond) NULL
[01:28:09.906]                   }
[01:28:09.906]                 })
[01:28:09.906]                 withCallingHandlers({
[01:28:09.906]                   value(a) + 1
[01:28:09.906]                 }, immediateCondition = function(cond) {
[01:28:09.906]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.906]                   sendCondition(cond)
[01:28:09.906]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.906]                   {
[01:28:09.906]                     inherits <- base::inherits
[01:28:09.906]                     invokeRestart <- base::invokeRestart
[01:28:09.906]                     is.null <- base::is.null
[01:28:09.906]                     muffled <- FALSE
[01:28:09.906]                     if (inherits(cond, "message")) {
[01:28:09.906]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.906]                       if (muffled) 
[01:28:09.906]                         invokeRestart("muffleMessage")
[01:28:09.906]                     }
[01:28:09.906]                     else if (inherits(cond, "warning")) {
[01:28:09.906]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.906]                       if (muffled) 
[01:28:09.906]                         invokeRestart("muffleWarning")
[01:28:09.906]                     }
[01:28:09.906]                     else if (inherits(cond, "condition")) {
[01:28:09.906]                       if (!is.null(pattern)) {
[01:28:09.906]                         computeRestarts <- base::computeRestarts
[01:28:09.906]                         grepl <- base::grepl
[01:28:09.906]                         restarts <- computeRestarts(cond)
[01:28:09.906]                         for (restart in restarts) {
[01:28:09.906]                           name <- restart$name
[01:28:09.906]                           if (is.null(name)) 
[01:28:09.906]                             next
[01:28:09.906]                           if (!grepl(pattern, name)) 
[01:28:09.906]                             next
[01:28:09.906]                           invokeRestart(restart)
[01:28:09.906]                           muffled <- TRUE
[01:28:09.906]                           break
[01:28:09.906]                         }
[01:28:09.906]                       }
[01:28:09.906]                     }
[01:28:09.906]                     invisible(muffled)
[01:28:09.906]                   }
[01:28:09.906]                   muffleCondition(cond)
[01:28:09.906]                 })
[01:28:09.906]             }))
[01:28:09.906]             future::FutureResult(value = ...future.value$value, 
[01:28:09.906]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.906]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.906]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.906]                     ...future.globalenv.names))
[01:28:09.906]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.906]         }, condition = base::local({
[01:28:09.906]             c <- base::c
[01:28:09.906]             inherits <- base::inherits
[01:28:09.906]             invokeRestart <- base::invokeRestart
[01:28:09.906]             length <- base::length
[01:28:09.906]             list <- base::list
[01:28:09.906]             seq.int <- base::seq.int
[01:28:09.906]             signalCondition <- base::signalCondition
[01:28:09.906]             sys.calls <- base::sys.calls
[01:28:09.906]             `[[` <- base::`[[`
[01:28:09.906]             `+` <- base::`+`
[01:28:09.906]             `<<-` <- base::`<<-`
[01:28:09.906]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.906]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.906]                   3L)]
[01:28:09.906]             }
[01:28:09.906]             function(cond) {
[01:28:09.906]                 is_error <- inherits(cond, "error")
[01:28:09.906]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.906]                   NULL)
[01:28:09.906]                 if (is_error) {
[01:28:09.906]                   sessionInformation <- function() {
[01:28:09.906]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.906]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.906]                       search = base::search(), system = base::Sys.info())
[01:28:09.906]                   }
[01:28:09.906]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.906]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.906]                     cond$call), session = sessionInformation(), 
[01:28:09.906]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.906]                   signalCondition(cond)
[01:28:09.906]                 }
[01:28:09.906]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.906]                 "immediateCondition"))) {
[01:28:09.906]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.906]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.906]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.906]                   if (TRUE && !signal) {
[01:28:09.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.906]                     {
[01:28:09.906]                       inherits <- base::inherits
[01:28:09.906]                       invokeRestart <- base::invokeRestart
[01:28:09.906]                       is.null <- base::is.null
[01:28:09.906]                       muffled <- FALSE
[01:28:09.906]                       if (inherits(cond, "message")) {
[01:28:09.906]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.906]                         if (muffled) 
[01:28:09.906]                           invokeRestart("muffleMessage")
[01:28:09.906]                       }
[01:28:09.906]                       else if (inherits(cond, "warning")) {
[01:28:09.906]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.906]                         if (muffled) 
[01:28:09.906]                           invokeRestart("muffleWarning")
[01:28:09.906]                       }
[01:28:09.906]                       else if (inherits(cond, "condition")) {
[01:28:09.906]                         if (!is.null(pattern)) {
[01:28:09.906]                           computeRestarts <- base::computeRestarts
[01:28:09.906]                           grepl <- base::grepl
[01:28:09.906]                           restarts <- computeRestarts(cond)
[01:28:09.906]                           for (restart in restarts) {
[01:28:09.906]                             name <- restart$name
[01:28:09.906]                             if (is.null(name)) 
[01:28:09.906]                               next
[01:28:09.906]                             if (!grepl(pattern, name)) 
[01:28:09.906]                               next
[01:28:09.906]                             invokeRestart(restart)
[01:28:09.906]                             muffled <- TRUE
[01:28:09.906]                             break
[01:28:09.906]                           }
[01:28:09.906]                         }
[01:28:09.906]                       }
[01:28:09.906]                       invisible(muffled)
[01:28:09.906]                     }
[01:28:09.906]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.906]                   }
[01:28:09.906]                 }
[01:28:09.906]                 else {
[01:28:09.906]                   if (TRUE) {
[01:28:09.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.906]                     {
[01:28:09.906]                       inherits <- base::inherits
[01:28:09.906]                       invokeRestart <- base::invokeRestart
[01:28:09.906]                       is.null <- base::is.null
[01:28:09.906]                       muffled <- FALSE
[01:28:09.906]                       if (inherits(cond, "message")) {
[01:28:09.906]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.906]                         if (muffled) 
[01:28:09.906]                           invokeRestart("muffleMessage")
[01:28:09.906]                       }
[01:28:09.906]                       else if (inherits(cond, "warning")) {
[01:28:09.906]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.906]                         if (muffled) 
[01:28:09.906]                           invokeRestart("muffleWarning")
[01:28:09.906]                       }
[01:28:09.906]                       else if (inherits(cond, "condition")) {
[01:28:09.906]                         if (!is.null(pattern)) {
[01:28:09.906]                           computeRestarts <- base::computeRestarts
[01:28:09.906]                           grepl <- base::grepl
[01:28:09.906]                           restarts <- computeRestarts(cond)
[01:28:09.906]                           for (restart in restarts) {
[01:28:09.906]                             name <- restart$name
[01:28:09.906]                             if (is.null(name)) 
[01:28:09.906]                               next
[01:28:09.906]                             if (!grepl(pattern, name)) 
[01:28:09.906]                               next
[01:28:09.906]                             invokeRestart(restart)
[01:28:09.906]                             muffled <- TRUE
[01:28:09.906]                             break
[01:28:09.906]                           }
[01:28:09.906]                         }
[01:28:09.906]                       }
[01:28:09.906]                       invisible(muffled)
[01:28:09.906]                     }
[01:28:09.906]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.906]                   }
[01:28:09.906]                 }
[01:28:09.906]             }
[01:28:09.906]         }))
[01:28:09.906]     }, error = function(ex) {
[01:28:09.906]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.906]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.906]                 ...future.rng), started = ...future.startTime, 
[01:28:09.906]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.906]             version = "1.8"), class = "FutureResult")
[01:28:09.906]     }, finally = {
[01:28:09.906]         if (!identical(...future.workdir, getwd())) 
[01:28:09.906]             setwd(...future.workdir)
[01:28:09.906]         {
[01:28:09.906]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.906]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.906]             }
[01:28:09.906]             base::options(...future.oldOptions)
[01:28:09.906]             if (.Platform$OS.type == "windows") {
[01:28:09.906]                 old_names <- names(...future.oldEnvVars)
[01:28:09.906]                 envs <- base::Sys.getenv()
[01:28:09.906]                 names <- names(envs)
[01:28:09.906]                 common <- intersect(names, old_names)
[01:28:09.906]                 added <- setdiff(names, old_names)
[01:28:09.906]                 removed <- setdiff(old_names, names)
[01:28:09.906]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.906]                   envs[common]]
[01:28:09.906]                 NAMES <- toupper(changed)
[01:28:09.906]                 args <- list()
[01:28:09.906]                 for (kk in seq_along(NAMES)) {
[01:28:09.906]                   name <- changed[[kk]]
[01:28:09.906]                   NAME <- NAMES[[kk]]
[01:28:09.906]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.906]                     next
[01:28:09.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.906]                 }
[01:28:09.906]                 NAMES <- toupper(added)
[01:28:09.906]                 for (kk in seq_along(NAMES)) {
[01:28:09.906]                   name <- added[[kk]]
[01:28:09.906]                   NAME <- NAMES[[kk]]
[01:28:09.906]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.906]                     next
[01:28:09.906]                   args[[name]] <- ""
[01:28:09.906]                 }
[01:28:09.906]                 NAMES <- toupper(removed)
[01:28:09.906]                 for (kk in seq_along(NAMES)) {
[01:28:09.906]                   name <- removed[[kk]]
[01:28:09.906]                   NAME <- NAMES[[kk]]
[01:28:09.906]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.906]                     next
[01:28:09.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.906]                 }
[01:28:09.906]                 if (length(args) > 0) 
[01:28:09.906]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.906]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.906]             }
[01:28:09.906]             else {
[01:28:09.906]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.906]             }
[01:28:09.906]             {
[01:28:09.906]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.906]                   0L) {
[01:28:09.906]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.906]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.906]                   base::options(opts)
[01:28:09.906]                 }
[01:28:09.906]                 {
[01:28:09.906]                   {
[01:28:09.906]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.906]                     NULL
[01:28:09.906]                   }
[01:28:09.906]                   options(future.plan = NULL)
[01:28:09.906]                   if (is.na(NA_character_)) 
[01:28:09.906]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.906]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.906]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.906]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.906]                     envir = parent.frame()) 
[01:28:09.906]                   {
[01:28:09.906]                     if (is.function(workers)) 
[01:28:09.906]                       workers <- workers()
[01:28:09.906]                     workers <- structure(as.integer(workers), 
[01:28:09.906]                       class = class(workers))
[01:28:09.906]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.906]                       workers >= 1)
[01:28:09.906]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.906]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.906]                     }
[01:28:09.906]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.906]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.906]                       envir = envir)
[01:28:09.906]                     if (!future$lazy) 
[01:28:09.906]                       future <- run(future)
[01:28:09.906]                     invisible(future)
[01:28:09.906]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.906]                 }
[01:28:09.906]             }
[01:28:09.906]         }
[01:28:09.906]     })
[01:28:09.906]     if (TRUE) {
[01:28:09.906]         base::sink(type = "output", split = FALSE)
[01:28:09.906]         if (TRUE) {
[01:28:09.906]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.906]         }
[01:28:09.906]         else {
[01:28:09.906]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.906]         }
[01:28:09.906]         base::close(...future.stdout)
[01:28:09.906]         ...future.stdout <- NULL
[01:28:09.906]     }
[01:28:09.906]     ...future.result$conditions <- ...future.conditions
[01:28:09.906]     ...future.result$finished <- base::Sys.time()
[01:28:09.906]     ...future.result
[01:28:09.906] }
[01:28:09.912] Exporting 1 global objects (10.05 KiB) to cluster node #2 ...
[01:28:09.914] Exporting 'a' (10.05 KiB) to cluster node #2 ...
[01:28:09.926] Exporting 'a' (10.05 KiB) to cluster node #2 ... DONE
[01:28:09.926] Exporting 1 global objects (10.05 KiB) to cluster node #2 ... DONE
[01:28:09.927] MultisessionFuture started
[01:28:09.927] - Launch lazy future ... done
[01:28:09.927] run() for 'MultisessionFuture' ... done
[01:28:09.927] result() for ClusterFuture ...
[01:28:09.928] receiveMessageFromWorker() for ClusterFuture ...
[01:28:09.928] - Validating connection of MultisessionFuture
[01:28:09.952] - received message: FutureResult
[01:28:09.952] - Received FutureResult
[01:28:09.952] - Erased future from FutureRegistry
[01:28:09.952] result() for ClusterFuture ...
[01:28:09.953] - result already collected: FutureResult
[01:28:09.953] result() for ClusterFuture ... done
[01:28:09.953] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:09.953] result() for ClusterFuture ... done
[01:28:09.953] result() for ClusterFuture ...
[01:28:09.954] - result already collected: FutureResult
[01:28:09.954] result() for ClusterFuture ... done
value(b) = 2
[01:28:09.954] result() for ClusterFuture ...
[01:28:09.954] - result already collected: FutureResult
[01:28:09.955] result() for ClusterFuture ... done
[01:28:09.955] result() for ClusterFuture ...
[01:28:09.955] - result already collected: FutureResult
[01:28:09.955] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.956] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.956] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.957] 
[01:28:09.958] Searching for globals ... DONE
[01:28:09.958] - globals: [0] <none>
[01:28:09.958] getGlobalsAndPackages() ... DONE
[01:28:09.958] run() for 'Future' ...
[01:28:09.959] - state: 'created'
[01:28:09.959] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:09.975] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:09.975] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:09.975]   - Field: 'node'
[01:28:09.975]   - Field: 'label'
[01:28:09.976]   - Field: 'local'
[01:28:09.976]   - Field: 'owner'
[01:28:09.976]   - Field: 'envir'
[01:28:09.976]   - Field: 'workers'
[01:28:09.977]   - Field: 'packages'
[01:28:09.977]   - Field: 'gc'
[01:28:09.977]   - Field: 'conditions'
[01:28:09.977]   - Field: 'persistent'
[01:28:09.977]   - Field: 'expr'
[01:28:09.978]   - Field: 'uuid'
[01:28:09.978]   - Field: 'seed'
[01:28:09.978]   - Field: 'version'
[01:28:09.978]   - Field: 'result'
[01:28:09.978]   - Field: 'asynchronous'
[01:28:09.979]   - Field: 'calls'
[01:28:09.979]   - Field: 'globals'
[01:28:09.979]   - Field: 'stdout'
[01:28:09.979]   - Field: 'earlySignal'
[01:28:09.980]   - Field: 'lazy'
[01:28:09.980]   - Field: 'state'
[01:28:09.980] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:09.980] - Launch lazy future ...
[01:28:09.981] Packages needed by the future expression (n = 0): <none>
[01:28:09.981] Packages needed by future strategies (n = 0): <none>
[01:28:09.982] {
[01:28:09.982]     {
[01:28:09.982]         {
[01:28:09.982]             ...future.startTime <- base::Sys.time()
[01:28:09.982]             {
[01:28:09.982]                 {
[01:28:09.982]                   {
[01:28:09.982]                     {
[01:28:09.982]                       base::local({
[01:28:09.982]                         has_future <- base::requireNamespace("future", 
[01:28:09.982]                           quietly = TRUE)
[01:28:09.982]                         if (has_future) {
[01:28:09.982]                           ns <- base::getNamespace("future")
[01:28:09.982]                           version <- ns[[".package"]][["version"]]
[01:28:09.982]                           if (is.null(version)) 
[01:28:09.982]                             version <- utils::packageVersion("future")
[01:28:09.982]                         }
[01:28:09.982]                         else {
[01:28:09.982]                           version <- NULL
[01:28:09.982]                         }
[01:28:09.982]                         if (!has_future || version < "1.8.0") {
[01:28:09.982]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:09.982]                             "", base::R.version$version.string), 
[01:28:09.982]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:09.982]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:09.982]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:09.982]                               "release", "version")], collapse = " "), 
[01:28:09.982]                             hostname = base::Sys.info()[["nodename"]])
[01:28:09.982]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:09.982]                             info)
[01:28:09.982]                           info <- base::paste(info, collapse = "; ")
[01:28:09.982]                           if (!has_future) {
[01:28:09.982]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:09.982]                               info)
[01:28:09.982]                           }
[01:28:09.982]                           else {
[01:28:09.982]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:09.982]                               info, version)
[01:28:09.982]                           }
[01:28:09.982]                           base::stop(msg)
[01:28:09.982]                         }
[01:28:09.982]                       })
[01:28:09.982]                     }
[01:28:09.982]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:09.982]                     base::options(mc.cores = 1L)
[01:28:09.982]                   }
[01:28:09.982]                   options(future.plan = NULL)
[01:28:09.982]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.982]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:09.982]                 }
[01:28:09.982]                 ...future.workdir <- getwd()
[01:28:09.982]             }
[01:28:09.982]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:09.982]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:09.982]         }
[01:28:09.982]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:09.982]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:09.982]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:09.982]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:09.982]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:09.982]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:09.982]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:09.982]             base::names(...future.oldOptions))
[01:28:09.982]     }
[01:28:09.982]     if (FALSE) {
[01:28:09.982]     }
[01:28:09.982]     else {
[01:28:09.982]         if (TRUE) {
[01:28:09.982]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:09.982]                 open = "w")
[01:28:09.982]         }
[01:28:09.982]         else {
[01:28:09.982]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:09.982]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:09.982]         }
[01:28:09.982]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:09.982]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:09.982]             base::sink(type = "output", split = FALSE)
[01:28:09.982]             base::close(...future.stdout)
[01:28:09.982]         }, add = TRUE)
[01:28:09.982]     }
[01:28:09.982]     ...future.frame <- base::sys.nframe()
[01:28:09.982]     ...future.conditions <- base::list()
[01:28:09.982]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:09.982]     if (FALSE) {
[01:28:09.982]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:09.982]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:09.982]     }
[01:28:09.982]     ...future.result <- base::tryCatch({
[01:28:09.982]         base::withCallingHandlers({
[01:28:09.982]             ...future.value <- base::withVisible(base::local({
[01:28:09.982]                 ...future.makeSendCondition <- base::local({
[01:28:09.982]                   sendCondition <- NULL
[01:28:09.982]                   function(frame = 1L) {
[01:28:09.982]                     if (is.function(sendCondition)) 
[01:28:09.982]                       return(sendCondition)
[01:28:09.982]                     ns <- getNamespace("parallel")
[01:28:09.982]                     if (exists("sendData", mode = "function", 
[01:28:09.982]                       envir = ns)) {
[01:28:09.982]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:09.982]                         envir = ns)
[01:28:09.982]                       envir <- sys.frame(frame)
[01:28:09.982]                       master <- NULL
[01:28:09.982]                       while (!identical(envir, .GlobalEnv) && 
[01:28:09.982]                         !identical(envir, emptyenv())) {
[01:28:09.982]                         if (exists("master", mode = "list", envir = envir, 
[01:28:09.982]                           inherits = FALSE)) {
[01:28:09.982]                           master <- get("master", mode = "list", 
[01:28:09.982]                             envir = envir, inherits = FALSE)
[01:28:09.982]                           if (inherits(master, c("SOCKnode", 
[01:28:09.982]                             "SOCK0node"))) {
[01:28:09.982]                             sendCondition <<- function(cond) {
[01:28:09.982]                               data <- list(type = "VALUE", value = cond, 
[01:28:09.982]                                 success = TRUE)
[01:28:09.982]                               parallel_sendData(master, data)
[01:28:09.982]                             }
[01:28:09.982]                             return(sendCondition)
[01:28:09.982]                           }
[01:28:09.982]                         }
[01:28:09.982]                         frame <- frame + 1L
[01:28:09.982]                         envir <- sys.frame(frame)
[01:28:09.982]                       }
[01:28:09.982]                     }
[01:28:09.982]                     sendCondition <<- function(cond) NULL
[01:28:09.982]                   }
[01:28:09.982]                 })
[01:28:09.982]                 withCallingHandlers({
[01:28:09.982]                   1
[01:28:09.982]                 }, immediateCondition = function(cond) {
[01:28:09.982]                   sendCondition <- ...future.makeSendCondition()
[01:28:09.982]                   sendCondition(cond)
[01:28:09.982]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.982]                   {
[01:28:09.982]                     inherits <- base::inherits
[01:28:09.982]                     invokeRestart <- base::invokeRestart
[01:28:09.982]                     is.null <- base::is.null
[01:28:09.982]                     muffled <- FALSE
[01:28:09.982]                     if (inherits(cond, "message")) {
[01:28:09.982]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:09.982]                       if (muffled) 
[01:28:09.982]                         invokeRestart("muffleMessage")
[01:28:09.982]                     }
[01:28:09.982]                     else if (inherits(cond, "warning")) {
[01:28:09.982]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:09.982]                       if (muffled) 
[01:28:09.982]                         invokeRestart("muffleWarning")
[01:28:09.982]                     }
[01:28:09.982]                     else if (inherits(cond, "condition")) {
[01:28:09.982]                       if (!is.null(pattern)) {
[01:28:09.982]                         computeRestarts <- base::computeRestarts
[01:28:09.982]                         grepl <- base::grepl
[01:28:09.982]                         restarts <- computeRestarts(cond)
[01:28:09.982]                         for (restart in restarts) {
[01:28:09.982]                           name <- restart$name
[01:28:09.982]                           if (is.null(name)) 
[01:28:09.982]                             next
[01:28:09.982]                           if (!grepl(pattern, name)) 
[01:28:09.982]                             next
[01:28:09.982]                           invokeRestart(restart)
[01:28:09.982]                           muffled <- TRUE
[01:28:09.982]                           break
[01:28:09.982]                         }
[01:28:09.982]                       }
[01:28:09.982]                     }
[01:28:09.982]                     invisible(muffled)
[01:28:09.982]                   }
[01:28:09.982]                   muffleCondition(cond)
[01:28:09.982]                 })
[01:28:09.982]             }))
[01:28:09.982]             future::FutureResult(value = ...future.value$value, 
[01:28:09.982]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.982]                   ...future.rng), globalenv = if (FALSE) 
[01:28:09.982]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:09.982]                     ...future.globalenv.names))
[01:28:09.982]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:09.982]         }, condition = base::local({
[01:28:09.982]             c <- base::c
[01:28:09.982]             inherits <- base::inherits
[01:28:09.982]             invokeRestart <- base::invokeRestart
[01:28:09.982]             length <- base::length
[01:28:09.982]             list <- base::list
[01:28:09.982]             seq.int <- base::seq.int
[01:28:09.982]             signalCondition <- base::signalCondition
[01:28:09.982]             sys.calls <- base::sys.calls
[01:28:09.982]             `[[` <- base::`[[`
[01:28:09.982]             `+` <- base::`+`
[01:28:09.982]             `<<-` <- base::`<<-`
[01:28:09.982]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:09.982]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:09.982]                   3L)]
[01:28:09.982]             }
[01:28:09.982]             function(cond) {
[01:28:09.982]                 is_error <- inherits(cond, "error")
[01:28:09.982]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:09.982]                   NULL)
[01:28:09.982]                 if (is_error) {
[01:28:09.982]                   sessionInformation <- function() {
[01:28:09.982]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:09.982]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:09.982]                       search = base::search(), system = base::Sys.info())
[01:28:09.982]                   }
[01:28:09.982]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.982]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:09.982]                     cond$call), session = sessionInformation(), 
[01:28:09.982]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:09.982]                   signalCondition(cond)
[01:28:09.982]                 }
[01:28:09.982]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:09.982]                 "immediateCondition"))) {
[01:28:09.982]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:09.982]                   ...future.conditions[[length(...future.conditions) + 
[01:28:09.982]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:09.982]                   if (TRUE && !signal) {
[01:28:09.982]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.982]                     {
[01:28:09.982]                       inherits <- base::inherits
[01:28:09.982]                       invokeRestart <- base::invokeRestart
[01:28:09.982]                       is.null <- base::is.null
[01:28:09.982]                       muffled <- FALSE
[01:28:09.982]                       if (inherits(cond, "message")) {
[01:28:09.982]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.982]                         if (muffled) 
[01:28:09.982]                           invokeRestart("muffleMessage")
[01:28:09.982]                       }
[01:28:09.982]                       else if (inherits(cond, "warning")) {
[01:28:09.982]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.982]                         if (muffled) 
[01:28:09.982]                           invokeRestart("muffleWarning")
[01:28:09.982]                       }
[01:28:09.982]                       else if (inherits(cond, "condition")) {
[01:28:09.982]                         if (!is.null(pattern)) {
[01:28:09.982]                           computeRestarts <- base::computeRestarts
[01:28:09.982]                           grepl <- base::grepl
[01:28:09.982]                           restarts <- computeRestarts(cond)
[01:28:09.982]                           for (restart in restarts) {
[01:28:09.982]                             name <- restart$name
[01:28:09.982]                             if (is.null(name)) 
[01:28:09.982]                               next
[01:28:09.982]                             if (!grepl(pattern, name)) 
[01:28:09.982]                               next
[01:28:09.982]                             invokeRestart(restart)
[01:28:09.982]                             muffled <- TRUE
[01:28:09.982]                             break
[01:28:09.982]                           }
[01:28:09.982]                         }
[01:28:09.982]                       }
[01:28:09.982]                       invisible(muffled)
[01:28:09.982]                     }
[01:28:09.982]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.982]                   }
[01:28:09.982]                 }
[01:28:09.982]                 else {
[01:28:09.982]                   if (TRUE) {
[01:28:09.982]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:09.982]                     {
[01:28:09.982]                       inherits <- base::inherits
[01:28:09.982]                       invokeRestart <- base::invokeRestart
[01:28:09.982]                       is.null <- base::is.null
[01:28:09.982]                       muffled <- FALSE
[01:28:09.982]                       if (inherits(cond, "message")) {
[01:28:09.982]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:09.982]                         if (muffled) 
[01:28:09.982]                           invokeRestart("muffleMessage")
[01:28:09.982]                       }
[01:28:09.982]                       else if (inherits(cond, "warning")) {
[01:28:09.982]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:09.982]                         if (muffled) 
[01:28:09.982]                           invokeRestart("muffleWarning")
[01:28:09.982]                       }
[01:28:09.982]                       else if (inherits(cond, "condition")) {
[01:28:09.982]                         if (!is.null(pattern)) {
[01:28:09.982]                           computeRestarts <- base::computeRestarts
[01:28:09.982]                           grepl <- base::grepl
[01:28:09.982]                           restarts <- computeRestarts(cond)
[01:28:09.982]                           for (restart in restarts) {
[01:28:09.982]                             name <- restart$name
[01:28:09.982]                             if (is.null(name)) 
[01:28:09.982]                               next
[01:28:09.982]                             if (!grepl(pattern, name)) 
[01:28:09.982]                               next
[01:28:09.982]                             invokeRestart(restart)
[01:28:09.982]                             muffled <- TRUE
[01:28:09.982]                             break
[01:28:09.982]                           }
[01:28:09.982]                         }
[01:28:09.982]                       }
[01:28:09.982]                       invisible(muffled)
[01:28:09.982]                     }
[01:28:09.982]                     muffleCondition(cond, pattern = "^muffle")
[01:28:09.982]                   }
[01:28:09.982]                 }
[01:28:09.982]             }
[01:28:09.982]         }))
[01:28:09.982]     }, error = function(ex) {
[01:28:09.982]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:09.982]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:09.982]                 ...future.rng), started = ...future.startTime, 
[01:28:09.982]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:09.982]             version = "1.8"), class = "FutureResult")
[01:28:09.982]     }, finally = {
[01:28:09.982]         if (!identical(...future.workdir, getwd())) 
[01:28:09.982]             setwd(...future.workdir)
[01:28:09.982]         {
[01:28:09.982]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:09.982]                 ...future.oldOptions$nwarnings <- NULL
[01:28:09.982]             }
[01:28:09.982]             base::options(...future.oldOptions)
[01:28:09.982]             if (.Platform$OS.type == "windows") {
[01:28:09.982]                 old_names <- names(...future.oldEnvVars)
[01:28:09.982]                 envs <- base::Sys.getenv()
[01:28:09.982]                 names <- names(envs)
[01:28:09.982]                 common <- intersect(names, old_names)
[01:28:09.982]                 added <- setdiff(names, old_names)
[01:28:09.982]                 removed <- setdiff(old_names, names)
[01:28:09.982]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:09.982]                   envs[common]]
[01:28:09.982]                 NAMES <- toupper(changed)
[01:28:09.982]                 args <- list()
[01:28:09.982]                 for (kk in seq_along(NAMES)) {
[01:28:09.982]                   name <- changed[[kk]]
[01:28:09.982]                   NAME <- NAMES[[kk]]
[01:28:09.982]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.982]                     next
[01:28:09.982]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.982]                 }
[01:28:09.982]                 NAMES <- toupper(added)
[01:28:09.982]                 for (kk in seq_along(NAMES)) {
[01:28:09.982]                   name <- added[[kk]]
[01:28:09.982]                   NAME <- NAMES[[kk]]
[01:28:09.982]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.982]                     next
[01:28:09.982]                   args[[name]] <- ""
[01:28:09.982]                 }
[01:28:09.982]                 NAMES <- toupper(removed)
[01:28:09.982]                 for (kk in seq_along(NAMES)) {
[01:28:09.982]                   name <- removed[[kk]]
[01:28:09.982]                   NAME <- NAMES[[kk]]
[01:28:09.982]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:09.982]                     next
[01:28:09.982]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:09.982]                 }
[01:28:09.982]                 if (length(args) > 0) 
[01:28:09.982]                   base::do.call(base::Sys.setenv, args = args)
[01:28:09.982]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:09.982]             }
[01:28:09.982]             else {
[01:28:09.982]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:09.982]             }
[01:28:09.982]             {
[01:28:09.982]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:09.982]                   0L) {
[01:28:09.982]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:09.982]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:09.982]                   base::options(opts)
[01:28:09.982]                 }
[01:28:09.982]                 {
[01:28:09.982]                   {
[01:28:09.982]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:09.982]                     NULL
[01:28:09.982]                   }
[01:28:09.982]                   options(future.plan = NULL)
[01:28:09.982]                   if (is.na(NA_character_)) 
[01:28:09.982]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:09.982]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:09.982]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:09.982]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:09.982]                     envir = parent.frame()) 
[01:28:09.982]                   {
[01:28:09.982]                     if (is.function(workers)) 
[01:28:09.982]                       workers <- workers()
[01:28:09.982]                     workers <- structure(as.integer(workers), 
[01:28:09.982]                       class = class(workers))
[01:28:09.982]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:09.982]                       workers >= 1)
[01:28:09.982]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:09.982]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:09.982]                     }
[01:28:09.982]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:09.982]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:09.982]                       envir = envir)
[01:28:09.982]                     if (!future$lazy) 
[01:28:09.982]                       future <- run(future)
[01:28:09.982]                     invisible(future)
[01:28:09.982]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:09.982]                 }
[01:28:09.982]             }
[01:28:09.982]         }
[01:28:09.982]     })
[01:28:09.982]     if (TRUE) {
[01:28:09.982]         base::sink(type = "output", split = FALSE)
[01:28:09.982]         if (TRUE) {
[01:28:09.982]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:09.982]         }
[01:28:09.982]         else {
[01:28:09.982]             ...future.result["stdout"] <- base::list(NULL)
[01:28:09.982]         }
[01:28:09.982]         base::close(...future.stdout)
[01:28:09.982]         ...future.stdout <- NULL
[01:28:09.982]     }
[01:28:09.982]     ...future.result$conditions <- ...future.conditions
[01:28:09.982]     ...future.result$finished <- base::Sys.time()
[01:28:09.982]     ...future.result
[01:28:09.982] }
[01:28:09.988] MultisessionFuture started
[01:28:09.988] - Launch lazy future ... done
[01:28:09.988] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:09.989] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:09.989] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:09.990] - globals found: [3] '+', 'value', 'a'
[01:28:09.991] Searching for globals ... DONE
[01:28:09.991] Resolving globals: TRUE
[01:28:09.991] Resolving any globals that are futures ...
[01:28:09.991] - globals: [3] '+', 'value', 'a'
[01:28:09.991] Resolving any globals that are futures ... DONE
[01:28:09.992] Resolving futures part of globals (recursively) ...
[01:28:09.992] resolve() on list ...
[01:28:09.992]  recursive: 99
[01:28:09.993]  length: 1
[01:28:09.993]  elements: 'a'
[01:28:10.006] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.007] - Validating connection of MultisessionFuture
[01:28:10.007] - received message: FutureResult
[01:28:10.007] - Received FutureResult
[01:28:10.007] - Erased future from FutureRegistry
[01:28:10.008] result() for ClusterFuture ...
[01:28:10.008] - result already collected: FutureResult
[01:28:10.008] result() for ClusterFuture ... done
[01:28:10.008] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.008] Future #1
[01:28:10.009] result() for ClusterFuture ...
[01:28:10.009] - result already collected: FutureResult
[01:28:10.009] result() for ClusterFuture ... done
[01:28:10.009] result() for ClusterFuture ...
[01:28:10.009] - result already collected: FutureResult
[01:28:10.009] result() for ClusterFuture ... done
[01:28:10.010] A MultisessionFuture was resolved
[01:28:10.010]  length: 0 (resolved future 1)
[01:28:10.010] resolve() on list ... DONE
[01:28:10.010] - globals: [1] 'a'
[01:28:10.011] Resolving futures part of globals (recursively) ... DONE
[01:28:10.012] The total size of the 1 globals is 10.05 KiB (10296 bytes)
[01:28:10.012] The total size of the 1 globals exported for future expression ('value(a) + 1') is 10.05 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (10.05 KiB of class 'environment')
[01:28:10.013] - globals: [1] 'a'
[01:28:10.013] - packages: [1] 'future'
[01:28:10.013] getGlobalsAndPackages() ... DONE
[01:28:10.014] run() for 'Future' ...
[01:28:10.014] - state: 'created'
[01:28:10.014] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.029] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.029] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.030]   - Field: 'node'
[01:28:10.030]   - Field: 'label'
[01:28:10.030]   - Field: 'local'
[01:28:10.030]   - Field: 'owner'
[01:28:10.030]   - Field: 'envir'
[01:28:10.030]   - Field: 'workers'
[01:28:10.031]   - Field: 'packages'
[01:28:10.031]   - Field: 'gc'
[01:28:10.031]   - Field: 'conditions'
[01:28:10.031]   - Field: 'persistent'
[01:28:10.031]   - Field: 'expr'
[01:28:10.032]   - Field: 'uuid'
[01:28:10.032]   - Field: 'seed'
[01:28:10.032]   - Field: 'version'
[01:28:10.032]   - Field: 'result'
[01:28:10.032]   - Field: 'asynchronous'
[01:28:10.032]   - Field: 'calls'
[01:28:10.033]   - Field: 'globals'
[01:28:10.033]   - Field: 'stdout'
[01:28:10.033]   - Field: 'earlySignal'
[01:28:10.033]   - Field: 'lazy'
[01:28:10.033]   - Field: 'state'
[01:28:10.034] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.034] - Launch lazy future ...
[01:28:10.034] Packages needed by the future expression (n = 1): 'future'
[01:28:10.034] Packages needed by future strategies (n = 0): <none>
[01:28:10.035] {
[01:28:10.035]     {
[01:28:10.035]         {
[01:28:10.035]             ...future.startTime <- base::Sys.time()
[01:28:10.035]             {
[01:28:10.035]                 {
[01:28:10.035]                   {
[01:28:10.035]                     {
[01:28:10.035]                       {
[01:28:10.035]                         base::local({
[01:28:10.035]                           has_future <- base::requireNamespace("future", 
[01:28:10.035]                             quietly = TRUE)
[01:28:10.035]                           if (has_future) {
[01:28:10.035]                             ns <- base::getNamespace("future")
[01:28:10.035]                             version <- ns[[".package"]][["version"]]
[01:28:10.035]                             if (is.null(version)) 
[01:28:10.035]                               version <- utils::packageVersion("future")
[01:28:10.035]                           }
[01:28:10.035]                           else {
[01:28:10.035]                             version <- NULL
[01:28:10.035]                           }
[01:28:10.035]                           if (!has_future || version < "1.8.0") {
[01:28:10.035]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.035]                               "", base::R.version$version.string), 
[01:28:10.035]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:10.035]                                 base::R.version$platform, 8 * 
[01:28:10.035]                                   base::.Machine$sizeof.pointer), 
[01:28:10.035]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.035]                                 "release", "version")], collapse = " "), 
[01:28:10.035]                               hostname = base::Sys.info()[["nodename"]])
[01:28:10.035]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.035]                               info)
[01:28:10.035]                             info <- base::paste(info, collapse = "; ")
[01:28:10.035]                             if (!has_future) {
[01:28:10.035]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.035]                                 info)
[01:28:10.035]                             }
[01:28:10.035]                             else {
[01:28:10.035]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.035]                                 info, version)
[01:28:10.035]                             }
[01:28:10.035]                             base::stop(msg)
[01:28:10.035]                           }
[01:28:10.035]                         })
[01:28:10.035]                       }
[01:28:10.035]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.035]                       base::options(mc.cores = 1L)
[01:28:10.035]                     }
[01:28:10.035]                     base::local({
[01:28:10.035]                       for (pkg in "future") {
[01:28:10.035]                         base::loadNamespace(pkg)
[01:28:10.035]                         base::library(pkg, character.only = TRUE)
[01:28:10.035]                       }
[01:28:10.035]                     })
[01:28:10.035]                   }
[01:28:10.035]                   options(future.plan = NULL)
[01:28:10.035]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.035]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.035]                 }
[01:28:10.035]                 ...future.workdir <- getwd()
[01:28:10.035]             }
[01:28:10.035]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.035]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.035]         }
[01:28:10.035]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.035]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:10.035]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.035]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.035]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.035]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.035]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.035]             base::names(...future.oldOptions))
[01:28:10.035]     }
[01:28:10.035]     if (FALSE) {
[01:28:10.035]     }
[01:28:10.035]     else {
[01:28:10.035]         if (TRUE) {
[01:28:10.035]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.035]                 open = "w")
[01:28:10.035]         }
[01:28:10.035]         else {
[01:28:10.035]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.035]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.035]         }
[01:28:10.035]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.035]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.035]             base::sink(type = "output", split = FALSE)
[01:28:10.035]             base::close(...future.stdout)
[01:28:10.035]         }, add = TRUE)
[01:28:10.035]     }
[01:28:10.035]     ...future.frame <- base::sys.nframe()
[01:28:10.035]     ...future.conditions <- base::list()
[01:28:10.035]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.035]     if (FALSE) {
[01:28:10.035]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.035]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.035]     }
[01:28:10.035]     ...future.result <- base::tryCatch({
[01:28:10.035]         base::withCallingHandlers({
[01:28:10.035]             ...future.value <- base::withVisible(base::local({
[01:28:10.035]                 ...future.makeSendCondition <- base::local({
[01:28:10.035]                   sendCondition <- NULL
[01:28:10.035]                   function(frame = 1L) {
[01:28:10.035]                     if (is.function(sendCondition)) 
[01:28:10.035]                       return(sendCondition)
[01:28:10.035]                     ns <- getNamespace("parallel")
[01:28:10.035]                     if (exists("sendData", mode = "function", 
[01:28:10.035]                       envir = ns)) {
[01:28:10.035]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.035]                         envir = ns)
[01:28:10.035]                       envir <- sys.frame(frame)
[01:28:10.035]                       master <- NULL
[01:28:10.035]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.035]                         !identical(envir, emptyenv())) {
[01:28:10.035]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.035]                           inherits = FALSE)) {
[01:28:10.035]                           master <- get("master", mode = "list", 
[01:28:10.035]                             envir = envir, inherits = FALSE)
[01:28:10.035]                           if (inherits(master, c("SOCKnode", 
[01:28:10.035]                             "SOCK0node"))) {
[01:28:10.035]                             sendCondition <<- function(cond) {
[01:28:10.035]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.035]                                 success = TRUE)
[01:28:10.035]                               parallel_sendData(master, data)
[01:28:10.035]                             }
[01:28:10.035]                             return(sendCondition)
[01:28:10.035]                           }
[01:28:10.035]                         }
[01:28:10.035]                         frame <- frame + 1L
[01:28:10.035]                         envir <- sys.frame(frame)
[01:28:10.035]                       }
[01:28:10.035]                     }
[01:28:10.035]                     sendCondition <<- function(cond) NULL
[01:28:10.035]                   }
[01:28:10.035]                 })
[01:28:10.035]                 withCallingHandlers({
[01:28:10.035]                   value(a) + 1
[01:28:10.035]                 }, immediateCondition = function(cond) {
[01:28:10.035]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.035]                   sendCondition(cond)
[01:28:10.035]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.035]                   {
[01:28:10.035]                     inherits <- base::inherits
[01:28:10.035]                     invokeRestart <- base::invokeRestart
[01:28:10.035]                     is.null <- base::is.null
[01:28:10.035]                     muffled <- FALSE
[01:28:10.035]                     if (inherits(cond, "message")) {
[01:28:10.035]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.035]                       if (muffled) 
[01:28:10.035]                         invokeRestart("muffleMessage")
[01:28:10.035]                     }
[01:28:10.035]                     else if (inherits(cond, "warning")) {
[01:28:10.035]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.035]                       if (muffled) 
[01:28:10.035]                         invokeRestart("muffleWarning")
[01:28:10.035]                     }
[01:28:10.035]                     else if (inherits(cond, "condition")) {
[01:28:10.035]                       if (!is.null(pattern)) {
[01:28:10.035]                         computeRestarts <- base::computeRestarts
[01:28:10.035]                         grepl <- base::grepl
[01:28:10.035]                         restarts <- computeRestarts(cond)
[01:28:10.035]                         for (restart in restarts) {
[01:28:10.035]                           name <- restart$name
[01:28:10.035]                           if (is.null(name)) 
[01:28:10.035]                             next
[01:28:10.035]                           if (!grepl(pattern, name)) 
[01:28:10.035]                             next
[01:28:10.035]                           invokeRestart(restart)
[01:28:10.035]                           muffled <- TRUE
[01:28:10.035]                           break
[01:28:10.035]                         }
[01:28:10.035]                       }
[01:28:10.035]                     }
[01:28:10.035]                     invisible(muffled)
[01:28:10.035]                   }
[01:28:10.035]                   muffleCondition(cond)
[01:28:10.035]                 })
[01:28:10.035]             }))
[01:28:10.035]             future::FutureResult(value = ...future.value$value, 
[01:28:10.035]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.035]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.035]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.035]                     ...future.globalenv.names))
[01:28:10.035]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.035]         }, condition = base::local({
[01:28:10.035]             c <- base::c
[01:28:10.035]             inherits <- base::inherits
[01:28:10.035]             invokeRestart <- base::invokeRestart
[01:28:10.035]             length <- base::length
[01:28:10.035]             list <- base::list
[01:28:10.035]             seq.int <- base::seq.int
[01:28:10.035]             signalCondition <- base::signalCondition
[01:28:10.035]             sys.calls <- base::sys.calls
[01:28:10.035]             `[[` <- base::`[[`
[01:28:10.035]             `+` <- base::`+`
[01:28:10.035]             `<<-` <- base::`<<-`
[01:28:10.035]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.035]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.035]                   3L)]
[01:28:10.035]             }
[01:28:10.035]             function(cond) {
[01:28:10.035]                 is_error <- inherits(cond, "error")
[01:28:10.035]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.035]                   NULL)
[01:28:10.035]                 if (is_error) {
[01:28:10.035]                   sessionInformation <- function() {
[01:28:10.035]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.035]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.035]                       search = base::search(), system = base::Sys.info())
[01:28:10.035]                   }
[01:28:10.035]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.035]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.035]                     cond$call), session = sessionInformation(), 
[01:28:10.035]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.035]                   signalCondition(cond)
[01:28:10.035]                 }
[01:28:10.035]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.035]                 "immediateCondition"))) {
[01:28:10.035]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.035]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.035]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.035]                   if (TRUE && !signal) {
[01:28:10.035]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.035]                     {
[01:28:10.035]                       inherits <- base::inherits
[01:28:10.035]                       invokeRestart <- base::invokeRestart
[01:28:10.035]                       is.null <- base::is.null
[01:28:10.035]                       muffled <- FALSE
[01:28:10.035]                       if (inherits(cond, "message")) {
[01:28:10.035]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.035]                         if (muffled) 
[01:28:10.035]                           invokeRestart("muffleMessage")
[01:28:10.035]                       }
[01:28:10.035]                       else if (inherits(cond, "warning")) {
[01:28:10.035]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.035]                         if (muffled) 
[01:28:10.035]                           invokeRestart("muffleWarning")
[01:28:10.035]                       }
[01:28:10.035]                       else if (inherits(cond, "condition")) {
[01:28:10.035]                         if (!is.null(pattern)) {
[01:28:10.035]                           computeRestarts <- base::computeRestarts
[01:28:10.035]                           grepl <- base::grepl
[01:28:10.035]                           restarts <- computeRestarts(cond)
[01:28:10.035]                           for (restart in restarts) {
[01:28:10.035]                             name <- restart$name
[01:28:10.035]                             if (is.null(name)) 
[01:28:10.035]                               next
[01:28:10.035]                             if (!grepl(pattern, name)) 
[01:28:10.035]                               next
[01:28:10.035]                             invokeRestart(restart)
[01:28:10.035]                             muffled <- TRUE
[01:28:10.035]                             break
[01:28:10.035]                           }
[01:28:10.035]                         }
[01:28:10.035]                       }
[01:28:10.035]                       invisible(muffled)
[01:28:10.035]                     }
[01:28:10.035]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.035]                   }
[01:28:10.035]                 }
[01:28:10.035]                 else {
[01:28:10.035]                   if (TRUE) {
[01:28:10.035]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.035]                     {
[01:28:10.035]                       inherits <- base::inherits
[01:28:10.035]                       invokeRestart <- base::invokeRestart
[01:28:10.035]                       is.null <- base::is.null
[01:28:10.035]                       muffled <- FALSE
[01:28:10.035]                       if (inherits(cond, "message")) {
[01:28:10.035]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.035]                         if (muffled) 
[01:28:10.035]                           invokeRestart("muffleMessage")
[01:28:10.035]                       }
[01:28:10.035]                       else if (inherits(cond, "warning")) {
[01:28:10.035]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.035]                         if (muffled) 
[01:28:10.035]                           invokeRestart("muffleWarning")
[01:28:10.035]                       }
[01:28:10.035]                       else if (inherits(cond, "condition")) {
[01:28:10.035]                         if (!is.null(pattern)) {
[01:28:10.035]                           computeRestarts <- base::computeRestarts
[01:28:10.035]                           grepl <- base::grepl
[01:28:10.035]                           restarts <- computeRestarts(cond)
[01:28:10.035]                           for (restart in restarts) {
[01:28:10.035]                             name <- restart$name
[01:28:10.035]                             if (is.null(name)) 
[01:28:10.035]                               next
[01:28:10.035]                             if (!grepl(pattern, name)) 
[01:28:10.035]                               next
[01:28:10.035]                             invokeRestart(restart)
[01:28:10.035]                             muffled <- TRUE
[01:28:10.035]                             break
[01:28:10.035]                           }
[01:28:10.035]                         }
[01:28:10.035]                       }
[01:28:10.035]                       invisible(muffled)
[01:28:10.035]                     }
[01:28:10.035]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.035]                   }
[01:28:10.035]                 }
[01:28:10.035]             }
[01:28:10.035]         }))
[01:28:10.035]     }, error = function(ex) {
[01:28:10.035]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.035]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.035]                 ...future.rng), started = ...future.startTime, 
[01:28:10.035]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.035]             version = "1.8"), class = "FutureResult")
[01:28:10.035]     }, finally = {
[01:28:10.035]         if (!identical(...future.workdir, getwd())) 
[01:28:10.035]             setwd(...future.workdir)
[01:28:10.035]         {
[01:28:10.035]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.035]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.035]             }
[01:28:10.035]             base::options(...future.oldOptions)
[01:28:10.035]             if (.Platform$OS.type == "windows") {
[01:28:10.035]                 old_names <- names(...future.oldEnvVars)
[01:28:10.035]                 envs <- base::Sys.getenv()
[01:28:10.035]                 names <- names(envs)
[01:28:10.035]                 common <- intersect(names, old_names)
[01:28:10.035]                 added <- setdiff(names, old_names)
[01:28:10.035]                 removed <- setdiff(old_names, names)
[01:28:10.035]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.035]                   envs[common]]
[01:28:10.035]                 NAMES <- toupper(changed)
[01:28:10.035]                 args <- list()
[01:28:10.035]                 for (kk in seq_along(NAMES)) {
[01:28:10.035]                   name <- changed[[kk]]
[01:28:10.035]                   NAME <- NAMES[[kk]]
[01:28:10.035]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.035]                     next
[01:28:10.035]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.035]                 }
[01:28:10.035]                 NAMES <- toupper(added)
[01:28:10.035]                 for (kk in seq_along(NAMES)) {
[01:28:10.035]                   name <- added[[kk]]
[01:28:10.035]                   NAME <- NAMES[[kk]]
[01:28:10.035]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.035]                     next
[01:28:10.035]                   args[[name]] <- ""
[01:28:10.035]                 }
[01:28:10.035]                 NAMES <- toupper(removed)
[01:28:10.035]                 for (kk in seq_along(NAMES)) {
[01:28:10.035]                   name <- removed[[kk]]
[01:28:10.035]                   NAME <- NAMES[[kk]]
[01:28:10.035]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.035]                     next
[01:28:10.035]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.035]                 }
[01:28:10.035]                 if (length(args) > 0) 
[01:28:10.035]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.035]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.035]             }
[01:28:10.035]             else {
[01:28:10.035]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.035]             }
[01:28:10.035]             {
[01:28:10.035]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.035]                   0L) {
[01:28:10.035]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.035]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.035]                   base::options(opts)
[01:28:10.035]                 }
[01:28:10.035]                 {
[01:28:10.035]                   {
[01:28:10.035]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.035]                     NULL
[01:28:10.035]                   }
[01:28:10.035]                   options(future.plan = NULL)
[01:28:10.035]                   if (is.na(NA_character_)) 
[01:28:10.035]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.035]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.035]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.035]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.035]                     envir = parent.frame()) 
[01:28:10.035]                   {
[01:28:10.035]                     if (is.function(workers)) 
[01:28:10.035]                       workers <- workers()
[01:28:10.035]                     workers <- structure(as.integer(workers), 
[01:28:10.035]                       class = class(workers))
[01:28:10.035]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.035]                       workers >= 1)
[01:28:10.035]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.035]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.035]                     }
[01:28:10.035]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.035]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.035]                       envir = envir)
[01:28:10.035]                     if (!future$lazy) 
[01:28:10.035]                       future <- run(future)
[01:28:10.035]                     invisible(future)
[01:28:10.035]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.035]                 }
[01:28:10.035]             }
[01:28:10.035]         }
[01:28:10.035]     })
[01:28:10.035]     if (TRUE) {
[01:28:10.035]         base::sink(type = "output", split = FALSE)
[01:28:10.035]         if (TRUE) {
[01:28:10.035]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.035]         }
[01:28:10.035]         else {
[01:28:10.035]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.035]         }
[01:28:10.035]         base::close(...future.stdout)
[01:28:10.035]         ...future.stdout <- NULL
[01:28:10.035]     }
[01:28:10.035]     ...future.result$conditions <- ...future.conditions
[01:28:10.035]     ...future.result$finished <- base::Sys.time()
[01:28:10.035]     ...future.result
[01:28:10.035] }
[01:28:10.041] Exporting 1 global objects (10.05 KiB) to cluster node #2 ...
[01:28:10.042] Exporting 'a' (10.05 KiB) to cluster node #2 ...
[01:28:10.054] Exporting 'a' (10.05 KiB) to cluster node #2 ... DONE
[01:28:10.054] Exporting 1 global objects (10.05 KiB) to cluster node #2 ... DONE
[01:28:10.055] MultisessionFuture started
[01:28:10.055] - Launch lazy future ... done
[01:28:10.055] run() for 'MultisessionFuture' ... done
[01:28:10.055] result() for ClusterFuture ...
[01:28:10.056] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.056] - Validating connection of MultisessionFuture
[01:28:10.073] - received message: FutureResult
[01:28:10.074] - Received FutureResult
[01:28:10.074] - Erased future from FutureRegistry
[01:28:10.074] result() for ClusterFuture ...
[01:28:10.074] - result already collected: FutureResult
[01:28:10.075] result() for ClusterFuture ... done
[01:28:10.075] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.075] result() for ClusterFuture ... done
[01:28:10.075] result() for ClusterFuture ...
[01:28:10.075] - result already collected: FutureResult
[01:28:10.075] result() for ClusterFuture ... done
value(b) = 2
[01:28:10.076] result() for ClusterFuture ...
[01:28:10.076] - result already collected: FutureResult
[01:28:10.076] result() for ClusterFuture ... done
[01:28:10.076] result() for ClusterFuture ...
[01:28:10.076] - result already collected: FutureResult
[01:28:10.077] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.077] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.077] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:10.078] 
[01:28:10.078] Searching for globals ... DONE
[01:28:10.079] - globals: [0] <none>
[01:28:10.079] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.079] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.080] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:10.081] - globals found: [3] '+', 'value', 'a'
[01:28:10.082] Searching for globals ... DONE
[01:28:10.082] Resolving globals: TRUE
[01:28:10.082] Resolving any globals that are futures ...
[01:28:10.082] - globals: [3] '+', 'value', 'a'
[01:28:10.082] Resolving any globals that are futures ... DONE
[01:28:10.083] Resolving futures part of globals (recursively) ...
[01:28:10.083] resolve() on list ...
[01:28:10.084]  recursive: 99
[01:28:10.084]  length: 1
[01:28:10.084]  elements: 'a'
[01:28:10.084] run() for 'Future' ...
[01:28:10.084] - state: 'created'
[01:28:10.085] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.100] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.101] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.101]   - Field: 'node'
[01:28:10.101]   - Field: 'label'
[01:28:10.101]   - Field: 'local'
[01:28:10.101]   - Field: 'owner'
[01:28:10.102]   - Field: 'envir'
[01:28:10.102]   - Field: 'workers'
[01:28:10.102]   - Field: 'packages'
[01:28:10.102]   - Field: 'gc'
[01:28:10.102]   - Field: 'conditions'
[01:28:10.103]   - Field: 'persistent'
[01:28:10.103]   - Field: 'expr'
[01:28:10.103]   - Field: 'uuid'
[01:28:10.103]   - Field: 'seed'
[01:28:10.103]   - Field: 'version'
[01:28:10.104]   - Field: 'result'
[01:28:10.104]   - Field: 'asynchronous'
[01:28:10.104]   - Field: 'calls'
[01:28:10.104]   - Field: 'globals'
[01:28:10.104]   - Field: 'stdout'
[01:28:10.105]   - Field: 'earlySignal'
[01:28:10.105]   - Field: 'lazy'
[01:28:10.105]   - Field: 'state'
[01:28:10.105] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.105] - Launch lazy future ...
[01:28:10.106] Packages needed by the future expression (n = 0): <none>
[01:28:10.106] Packages needed by future strategies (n = 0): <none>
[01:28:10.107] {
[01:28:10.107]     {
[01:28:10.107]         {
[01:28:10.107]             ...future.startTime <- base::Sys.time()
[01:28:10.107]             {
[01:28:10.107]                 {
[01:28:10.107]                   {
[01:28:10.107]                     {
[01:28:10.107]                       base::local({
[01:28:10.107]                         has_future <- base::requireNamespace("future", 
[01:28:10.107]                           quietly = TRUE)
[01:28:10.107]                         if (has_future) {
[01:28:10.107]                           ns <- base::getNamespace("future")
[01:28:10.107]                           version <- ns[[".package"]][["version"]]
[01:28:10.107]                           if (is.null(version)) 
[01:28:10.107]                             version <- utils::packageVersion("future")
[01:28:10.107]                         }
[01:28:10.107]                         else {
[01:28:10.107]                           version <- NULL
[01:28:10.107]                         }
[01:28:10.107]                         if (!has_future || version < "1.8.0") {
[01:28:10.107]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.107]                             "", base::R.version$version.string), 
[01:28:10.107]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.107]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.107]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.107]                               "release", "version")], collapse = " "), 
[01:28:10.107]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.107]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.107]                             info)
[01:28:10.107]                           info <- base::paste(info, collapse = "; ")
[01:28:10.107]                           if (!has_future) {
[01:28:10.107]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.107]                               info)
[01:28:10.107]                           }
[01:28:10.107]                           else {
[01:28:10.107]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.107]                               info, version)
[01:28:10.107]                           }
[01:28:10.107]                           base::stop(msg)
[01:28:10.107]                         }
[01:28:10.107]                       })
[01:28:10.107]                     }
[01:28:10.107]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.107]                     base::options(mc.cores = 1L)
[01:28:10.107]                   }
[01:28:10.107]                   options(future.plan = NULL)
[01:28:10.107]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.107]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.107]                 }
[01:28:10.107]                 ...future.workdir <- getwd()
[01:28:10.107]             }
[01:28:10.107]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.107]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.107]         }
[01:28:10.107]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.107]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:10.107]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.107]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.107]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.107]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.107]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.107]             base::names(...future.oldOptions))
[01:28:10.107]     }
[01:28:10.107]     if (FALSE) {
[01:28:10.107]     }
[01:28:10.107]     else {
[01:28:10.107]         if (TRUE) {
[01:28:10.107]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.107]                 open = "w")
[01:28:10.107]         }
[01:28:10.107]         else {
[01:28:10.107]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.107]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.107]         }
[01:28:10.107]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.107]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.107]             base::sink(type = "output", split = FALSE)
[01:28:10.107]             base::close(...future.stdout)
[01:28:10.107]         }, add = TRUE)
[01:28:10.107]     }
[01:28:10.107]     ...future.frame <- base::sys.nframe()
[01:28:10.107]     ...future.conditions <- base::list()
[01:28:10.107]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.107]     if (FALSE) {
[01:28:10.107]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.107]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.107]     }
[01:28:10.107]     ...future.result <- base::tryCatch({
[01:28:10.107]         base::withCallingHandlers({
[01:28:10.107]             ...future.value <- base::withVisible(base::local({
[01:28:10.107]                 ...future.makeSendCondition <- base::local({
[01:28:10.107]                   sendCondition <- NULL
[01:28:10.107]                   function(frame = 1L) {
[01:28:10.107]                     if (is.function(sendCondition)) 
[01:28:10.107]                       return(sendCondition)
[01:28:10.107]                     ns <- getNamespace("parallel")
[01:28:10.107]                     if (exists("sendData", mode = "function", 
[01:28:10.107]                       envir = ns)) {
[01:28:10.107]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.107]                         envir = ns)
[01:28:10.107]                       envir <- sys.frame(frame)
[01:28:10.107]                       master <- NULL
[01:28:10.107]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.107]                         !identical(envir, emptyenv())) {
[01:28:10.107]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.107]                           inherits = FALSE)) {
[01:28:10.107]                           master <- get("master", mode = "list", 
[01:28:10.107]                             envir = envir, inherits = FALSE)
[01:28:10.107]                           if (inherits(master, c("SOCKnode", 
[01:28:10.107]                             "SOCK0node"))) {
[01:28:10.107]                             sendCondition <<- function(cond) {
[01:28:10.107]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.107]                                 success = TRUE)
[01:28:10.107]                               parallel_sendData(master, data)
[01:28:10.107]                             }
[01:28:10.107]                             return(sendCondition)
[01:28:10.107]                           }
[01:28:10.107]                         }
[01:28:10.107]                         frame <- frame + 1L
[01:28:10.107]                         envir <- sys.frame(frame)
[01:28:10.107]                       }
[01:28:10.107]                     }
[01:28:10.107]                     sendCondition <<- function(cond) NULL
[01:28:10.107]                   }
[01:28:10.107]                 })
[01:28:10.107]                 withCallingHandlers({
[01:28:10.107]                   1
[01:28:10.107]                 }, immediateCondition = function(cond) {
[01:28:10.107]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.107]                   sendCondition(cond)
[01:28:10.107]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.107]                   {
[01:28:10.107]                     inherits <- base::inherits
[01:28:10.107]                     invokeRestart <- base::invokeRestart
[01:28:10.107]                     is.null <- base::is.null
[01:28:10.107]                     muffled <- FALSE
[01:28:10.107]                     if (inherits(cond, "message")) {
[01:28:10.107]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.107]                       if (muffled) 
[01:28:10.107]                         invokeRestart("muffleMessage")
[01:28:10.107]                     }
[01:28:10.107]                     else if (inherits(cond, "warning")) {
[01:28:10.107]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.107]                       if (muffled) 
[01:28:10.107]                         invokeRestart("muffleWarning")
[01:28:10.107]                     }
[01:28:10.107]                     else if (inherits(cond, "condition")) {
[01:28:10.107]                       if (!is.null(pattern)) {
[01:28:10.107]                         computeRestarts <- base::computeRestarts
[01:28:10.107]                         grepl <- base::grepl
[01:28:10.107]                         restarts <- computeRestarts(cond)
[01:28:10.107]                         for (restart in restarts) {
[01:28:10.107]                           name <- restart$name
[01:28:10.107]                           if (is.null(name)) 
[01:28:10.107]                             next
[01:28:10.107]                           if (!grepl(pattern, name)) 
[01:28:10.107]                             next
[01:28:10.107]                           invokeRestart(restart)
[01:28:10.107]                           muffled <- TRUE
[01:28:10.107]                           break
[01:28:10.107]                         }
[01:28:10.107]                       }
[01:28:10.107]                     }
[01:28:10.107]                     invisible(muffled)
[01:28:10.107]                   }
[01:28:10.107]                   muffleCondition(cond)
[01:28:10.107]                 })
[01:28:10.107]             }))
[01:28:10.107]             future::FutureResult(value = ...future.value$value, 
[01:28:10.107]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.107]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.107]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.107]                     ...future.globalenv.names))
[01:28:10.107]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.107]         }, condition = base::local({
[01:28:10.107]             c <- base::c
[01:28:10.107]             inherits <- base::inherits
[01:28:10.107]             invokeRestart <- base::invokeRestart
[01:28:10.107]             length <- base::length
[01:28:10.107]             list <- base::list
[01:28:10.107]             seq.int <- base::seq.int
[01:28:10.107]             signalCondition <- base::signalCondition
[01:28:10.107]             sys.calls <- base::sys.calls
[01:28:10.107]             `[[` <- base::`[[`
[01:28:10.107]             `+` <- base::`+`
[01:28:10.107]             `<<-` <- base::`<<-`
[01:28:10.107]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.107]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.107]                   3L)]
[01:28:10.107]             }
[01:28:10.107]             function(cond) {
[01:28:10.107]                 is_error <- inherits(cond, "error")
[01:28:10.107]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.107]                   NULL)
[01:28:10.107]                 if (is_error) {
[01:28:10.107]                   sessionInformation <- function() {
[01:28:10.107]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.107]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.107]                       search = base::search(), system = base::Sys.info())
[01:28:10.107]                   }
[01:28:10.107]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.107]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.107]                     cond$call), session = sessionInformation(), 
[01:28:10.107]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.107]                   signalCondition(cond)
[01:28:10.107]                 }
[01:28:10.107]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.107]                 "immediateCondition"))) {
[01:28:10.107]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.107]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.107]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.107]                   if (TRUE && !signal) {
[01:28:10.107]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.107]                     {
[01:28:10.107]                       inherits <- base::inherits
[01:28:10.107]                       invokeRestart <- base::invokeRestart
[01:28:10.107]                       is.null <- base::is.null
[01:28:10.107]                       muffled <- FALSE
[01:28:10.107]                       if (inherits(cond, "message")) {
[01:28:10.107]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.107]                         if (muffled) 
[01:28:10.107]                           invokeRestart("muffleMessage")
[01:28:10.107]                       }
[01:28:10.107]                       else if (inherits(cond, "warning")) {
[01:28:10.107]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.107]                         if (muffled) 
[01:28:10.107]                           invokeRestart("muffleWarning")
[01:28:10.107]                       }
[01:28:10.107]                       else if (inherits(cond, "condition")) {
[01:28:10.107]                         if (!is.null(pattern)) {
[01:28:10.107]                           computeRestarts <- base::computeRestarts
[01:28:10.107]                           grepl <- base::grepl
[01:28:10.107]                           restarts <- computeRestarts(cond)
[01:28:10.107]                           for (restart in restarts) {
[01:28:10.107]                             name <- restart$name
[01:28:10.107]                             if (is.null(name)) 
[01:28:10.107]                               next
[01:28:10.107]                             if (!grepl(pattern, name)) 
[01:28:10.107]                               next
[01:28:10.107]                             invokeRestart(restart)
[01:28:10.107]                             muffled <- TRUE
[01:28:10.107]                             break
[01:28:10.107]                           }
[01:28:10.107]                         }
[01:28:10.107]                       }
[01:28:10.107]                       invisible(muffled)
[01:28:10.107]                     }
[01:28:10.107]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.107]                   }
[01:28:10.107]                 }
[01:28:10.107]                 else {
[01:28:10.107]                   if (TRUE) {
[01:28:10.107]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.107]                     {
[01:28:10.107]                       inherits <- base::inherits
[01:28:10.107]                       invokeRestart <- base::invokeRestart
[01:28:10.107]                       is.null <- base::is.null
[01:28:10.107]                       muffled <- FALSE
[01:28:10.107]                       if (inherits(cond, "message")) {
[01:28:10.107]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.107]                         if (muffled) 
[01:28:10.107]                           invokeRestart("muffleMessage")
[01:28:10.107]                       }
[01:28:10.107]                       else if (inherits(cond, "warning")) {
[01:28:10.107]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.107]                         if (muffled) 
[01:28:10.107]                           invokeRestart("muffleWarning")
[01:28:10.107]                       }
[01:28:10.107]                       else if (inherits(cond, "condition")) {
[01:28:10.107]                         if (!is.null(pattern)) {
[01:28:10.107]                           computeRestarts <- base::computeRestarts
[01:28:10.107]                           grepl <- base::grepl
[01:28:10.107]                           restarts <- computeRestarts(cond)
[01:28:10.107]                           for (restart in restarts) {
[01:28:10.107]                             name <- restart$name
[01:28:10.107]                             if (is.null(name)) 
[01:28:10.107]                               next
[01:28:10.107]                             if (!grepl(pattern, name)) 
[01:28:10.107]                               next
[01:28:10.107]                             invokeRestart(restart)
[01:28:10.107]                             muffled <- TRUE
[01:28:10.107]                             break
[01:28:10.107]                           }
[01:28:10.107]                         }
[01:28:10.107]                       }
[01:28:10.107]                       invisible(muffled)
[01:28:10.107]                     }
[01:28:10.107]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.107]                   }
[01:28:10.107]                 }
[01:28:10.107]             }
[01:28:10.107]         }))
[01:28:10.107]     }, error = function(ex) {
[01:28:10.107]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.107]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.107]                 ...future.rng), started = ...future.startTime, 
[01:28:10.107]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.107]             version = "1.8"), class = "FutureResult")
[01:28:10.107]     }, finally = {
[01:28:10.107]         if (!identical(...future.workdir, getwd())) 
[01:28:10.107]             setwd(...future.workdir)
[01:28:10.107]         {
[01:28:10.107]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.107]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.107]             }
[01:28:10.107]             base::options(...future.oldOptions)
[01:28:10.107]             if (.Platform$OS.type == "windows") {
[01:28:10.107]                 old_names <- names(...future.oldEnvVars)
[01:28:10.107]                 envs <- base::Sys.getenv()
[01:28:10.107]                 names <- names(envs)
[01:28:10.107]                 common <- intersect(names, old_names)
[01:28:10.107]                 added <- setdiff(names, old_names)
[01:28:10.107]                 removed <- setdiff(old_names, names)
[01:28:10.107]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.107]                   envs[common]]
[01:28:10.107]                 NAMES <- toupper(changed)
[01:28:10.107]                 args <- list()
[01:28:10.107]                 for (kk in seq_along(NAMES)) {
[01:28:10.107]                   name <- changed[[kk]]
[01:28:10.107]                   NAME <- NAMES[[kk]]
[01:28:10.107]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.107]                     next
[01:28:10.107]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.107]                 }
[01:28:10.107]                 NAMES <- toupper(added)
[01:28:10.107]                 for (kk in seq_along(NAMES)) {
[01:28:10.107]                   name <- added[[kk]]
[01:28:10.107]                   NAME <- NAMES[[kk]]
[01:28:10.107]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.107]                     next
[01:28:10.107]                   args[[name]] <- ""
[01:28:10.107]                 }
[01:28:10.107]                 NAMES <- toupper(removed)
[01:28:10.107]                 for (kk in seq_along(NAMES)) {
[01:28:10.107]                   name <- removed[[kk]]
[01:28:10.107]                   NAME <- NAMES[[kk]]
[01:28:10.107]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.107]                     next
[01:28:10.107]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.107]                 }
[01:28:10.107]                 if (length(args) > 0) 
[01:28:10.107]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.107]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.107]             }
[01:28:10.107]             else {
[01:28:10.107]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.107]             }
[01:28:10.107]             {
[01:28:10.107]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.107]                   0L) {
[01:28:10.107]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.107]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.107]                   base::options(opts)
[01:28:10.107]                 }
[01:28:10.107]                 {
[01:28:10.107]                   {
[01:28:10.107]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.107]                     NULL
[01:28:10.107]                   }
[01:28:10.107]                   options(future.plan = NULL)
[01:28:10.107]                   if (is.na(NA_character_)) 
[01:28:10.107]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.107]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.107]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.107]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.107]                     envir = parent.frame()) 
[01:28:10.107]                   {
[01:28:10.107]                     if (is.function(workers)) 
[01:28:10.107]                       workers <- workers()
[01:28:10.107]                     workers <- structure(as.integer(workers), 
[01:28:10.107]                       class = class(workers))
[01:28:10.107]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.107]                       workers >= 1)
[01:28:10.107]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.107]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.107]                     }
[01:28:10.107]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.107]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.107]                       envir = envir)
[01:28:10.107]                     if (!future$lazy) 
[01:28:10.107]                       future <- run(future)
[01:28:10.107]                     invisible(future)
[01:28:10.107]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.107]                 }
[01:28:10.107]             }
[01:28:10.107]         }
[01:28:10.107]     })
[01:28:10.107]     if (TRUE) {
[01:28:10.107]         base::sink(type = "output", split = FALSE)
[01:28:10.107]         if (TRUE) {
[01:28:10.107]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.107]         }
[01:28:10.107]         else {
[01:28:10.107]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.107]         }
[01:28:10.107]         base::close(...future.stdout)
[01:28:10.107]         ...future.stdout <- NULL
[01:28:10.107]     }
[01:28:10.107]     ...future.result$conditions <- ...future.conditions
[01:28:10.107]     ...future.result$finished <- base::Sys.time()
[01:28:10.107]     ...future.result
[01:28:10.107] }
[01:28:10.113] MultisessionFuture started
[01:28:10.114] - Launch lazy future ... done
[01:28:10.114] run() for 'MultisessionFuture' ... done
[01:28:10.130] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.130] - Validating connection of MultisessionFuture
[01:28:10.131] - received message: FutureResult
[01:28:10.131] - Received FutureResult
[01:28:10.131] - Erased future from FutureRegistry
[01:28:10.131] result() for ClusterFuture ...
[01:28:10.132] - result already collected: FutureResult
[01:28:10.132] result() for ClusterFuture ... done
[01:28:10.132] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.132] Future #1
[01:28:10.133] result() for ClusterFuture ...
[01:28:10.133] - result already collected: FutureResult
[01:28:10.133] result() for ClusterFuture ... done
[01:28:10.133] result() for ClusterFuture ...
[01:28:10.134] - result already collected: FutureResult
[01:28:10.134] result() for ClusterFuture ... done
[01:28:10.134] A MultisessionFuture was resolved
[01:28:10.134]  length: 0 (resolved future 1)
[01:28:10.135] resolve() on list ... DONE
[01:28:10.135] - globals: [1] 'a'
[01:28:10.135] Resolving futures part of globals (recursively) ... DONE
[01:28:10.137] The total size of the 1 globals is 10.22 KiB (10464 bytes)
[01:28:10.138] The total size of the 1 globals exported for future expression ('value(a) + 1') is 10.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (10.22 KiB of class 'environment')
[01:28:10.138] - globals: [1] 'a'
[01:28:10.138] - packages: [1] 'future'
[01:28:10.138] getGlobalsAndPackages() ... DONE
[01:28:10.139] run() for 'Future' ...
[01:28:10.139] - state: 'created'
[01:28:10.140] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.156] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.156] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.156]   - Field: 'node'
[01:28:10.156]   - Field: 'label'
[01:28:10.156]   - Field: 'local'
[01:28:10.157]   - Field: 'owner'
[01:28:10.157]   - Field: 'envir'
[01:28:10.157]   - Field: 'workers'
[01:28:10.157]   - Field: 'packages'
[01:28:10.158]   - Field: 'gc'
[01:28:10.158]   - Field: 'conditions'
[01:28:10.158]   - Field: 'persistent'
[01:28:10.158]   - Field: 'expr'
[01:28:10.158]   - Field: 'uuid'
[01:28:10.159]   - Field: 'seed'
[01:28:10.159]   - Field: 'version'
[01:28:10.159]   - Field: 'result'
[01:28:10.159]   - Field: 'asynchronous'
[01:28:10.159]   - Field: 'calls'
[01:28:10.160]   - Field: 'globals'
[01:28:10.160]   - Field: 'stdout'
[01:28:10.160]   - Field: 'earlySignal'
[01:28:10.160]   - Field: 'lazy'
[01:28:10.161]   - Field: 'state'
[01:28:10.161] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.161] - Launch lazy future ...
[01:28:10.161] Packages needed by the future expression (n = 1): 'future'
[01:28:10.162] Packages needed by future strategies (n = 0): <none>
[01:28:10.163] {
[01:28:10.163]     {
[01:28:10.163]         {
[01:28:10.163]             ...future.startTime <- base::Sys.time()
[01:28:10.163]             {
[01:28:10.163]                 {
[01:28:10.163]                   {
[01:28:10.163]                     {
[01:28:10.163]                       {
[01:28:10.163]                         base::local({
[01:28:10.163]                           has_future <- base::requireNamespace("future", 
[01:28:10.163]                             quietly = TRUE)
[01:28:10.163]                           if (has_future) {
[01:28:10.163]                             ns <- base::getNamespace("future")
[01:28:10.163]                             version <- ns[[".package"]][["version"]]
[01:28:10.163]                             if (is.null(version)) 
[01:28:10.163]                               version <- utils::packageVersion("future")
[01:28:10.163]                           }
[01:28:10.163]                           else {
[01:28:10.163]                             version <- NULL
[01:28:10.163]                           }
[01:28:10.163]                           if (!has_future || version < "1.8.0") {
[01:28:10.163]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.163]                               "", base::R.version$version.string), 
[01:28:10.163]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:10.163]                                 base::R.version$platform, 8 * 
[01:28:10.163]                                   base::.Machine$sizeof.pointer), 
[01:28:10.163]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.163]                                 "release", "version")], collapse = " "), 
[01:28:10.163]                               hostname = base::Sys.info()[["nodename"]])
[01:28:10.163]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.163]                               info)
[01:28:10.163]                             info <- base::paste(info, collapse = "; ")
[01:28:10.163]                             if (!has_future) {
[01:28:10.163]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.163]                                 info)
[01:28:10.163]                             }
[01:28:10.163]                             else {
[01:28:10.163]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.163]                                 info, version)
[01:28:10.163]                             }
[01:28:10.163]                             base::stop(msg)
[01:28:10.163]                           }
[01:28:10.163]                         })
[01:28:10.163]                       }
[01:28:10.163]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.163]                       base::options(mc.cores = 1L)
[01:28:10.163]                     }
[01:28:10.163]                     base::local({
[01:28:10.163]                       for (pkg in "future") {
[01:28:10.163]                         base::loadNamespace(pkg)
[01:28:10.163]                         base::library(pkg, character.only = TRUE)
[01:28:10.163]                       }
[01:28:10.163]                     })
[01:28:10.163]                   }
[01:28:10.163]                   options(future.plan = NULL)
[01:28:10.163]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.163]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.163]                 }
[01:28:10.163]                 ...future.workdir <- getwd()
[01:28:10.163]             }
[01:28:10.163]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.163]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.163]         }
[01:28:10.163]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.163]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:10.163]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.163]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.163]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.163]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.163]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.163]             base::names(...future.oldOptions))
[01:28:10.163]     }
[01:28:10.163]     if (FALSE) {
[01:28:10.163]     }
[01:28:10.163]     else {
[01:28:10.163]         if (TRUE) {
[01:28:10.163]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.163]                 open = "w")
[01:28:10.163]         }
[01:28:10.163]         else {
[01:28:10.163]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.163]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.163]         }
[01:28:10.163]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.163]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.163]             base::sink(type = "output", split = FALSE)
[01:28:10.163]             base::close(...future.stdout)
[01:28:10.163]         }, add = TRUE)
[01:28:10.163]     }
[01:28:10.163]     ...future.frame <- base::sys.nframe()
[01:28:10.163]     ...future.conditions <- base::list()
[01:28:10.163]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.163]     if (FALSE) {
[01:28:10.163]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.163]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.163]     }
[01:28:10.163]     ...future.result <- base::tryCatch({
[01:28:10.163]         base::withCallingHandlers({
[01:28:10.163]             ...future.value <- base::withVisible(base::local({
[01:28:10.163]                 ...future.makeSendCondition <- base::local({
[01:28:10.163]                   sendCondition <- NULL
[01:28:10.163]                   function(frame = 1L) {
[01:28:10.163]                     if (is.function(sendCondition)) 
[01:28:10.163]                       return(sendCondition)
[01:28:10.163]                     ns <- getNamespace("parallel")
[01:28:10.163]                     if (exists("sendData", mode = "function", 
[01:28:10.163]                       envir = ns)) {
[01:28:10.163]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.163]                         envir = ns)
[01:28:10.163]                       envir <- sys.frame(frame)
[01:28:10.163]                       master <- NULL
[01:28:10.163]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.163]                         !identical(envir, emptyenv())) {
[01:28:10.163]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.163]                           inherits = FALSE)) {
[01:28:10.163]                           master <- get("master", mode = "list", 
[01:28:10.163]                             envir = envir, inherits = FALSE)
[01:28:10.163]                           if (inherits(master, c("SOCKnode", 
[01:28:10.163]                             "SOCK0node"))) {
[01:28:10.163]                             sendCondition <<- function(cond) {
[01:28:10.163]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.163]                                 success = TRUE)
[01:28:10.163]                               parallel_sendData(master, data)
[01:28:10.163]                             }
[01:28:10.163]                             return(sendCondition)
[01:28:10.163]                           }
[01:28:10.163]                         }
[01:28:10.163]                         frame <- frame + 1L
[01:28:10.163]                         envir <- sys.frame(frame)
[01:28:10.163]                       }
[01:28:10.163]                     }
[01:28:10.163]                     sendCondition <<- function(cond) NULL
[01:28:10.163]                   }
[01:28:10.163]                 })
[01:28:10.163]                 withCallingHandlers({
[01:28:10.163]                   value(a) + 1
[01:28:10.163]                 }, immediateCondition = function(cond) {
[01:28:10.163]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.163]                   sendCondition(cond)
[01:28:10.163]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.163]                   {
[01:28:10.163]                     inherits <- base::inherits
[01:28:10.163]                     invokeRestart <- base::invokeRestart
[01:28:10.163]                     is.null <- base::is.null
[01:28:10.163]                     muffled <- FALSE
[01:28:10.163]                     if (inherits(cond, "message")) {
[01:28:10.163]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.163]                       if (muffled) 
[01:28:10.163]                         invokeRestart("muffleMessage")
[01:28:10.163]                     }
[01:28:10.163]                     else if (inherits(cond, "warning")) {
[01:28:10.163]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.163]                       if (muffled) 
[01:28:10.163]                         invokeRestart("muffleWarning")
[01:28:10.163]                     }
[01:28:10.163]                     else if (inherits(cond, "condition")) {
[01:28:10.163]                       if (!is.null(pattern)) {
[01:28:10.163]                         computeRestarts <- base::computeRestarts
[01:28:10.163]                         grepl <- base::grepl
[01:28:10.163]                         restarts <- computeRestarts(cond)
[01:28:10.163]                         for (restart in restarts) {
[01:28:10.163]                           name <- restart$name
[01:28:10.163]                           if (is.null(name)) 
[01:28:10.163]                             next
[01:28:10.163]                           if (!grepl(pattern, name)) 
[01:28:10.163]                             next
[01:28:10.163]                           invokeRestart(restart)
[01:28:10.163]                           muffled <- TRUE
[01:28:10.163]                           break
[01:28:10.163]                         }
[01:28:10.163]                       }
[01:28:10.163]                     }
[01:28:10.163]                     invisible(muffled)
[01:28:10.163]                   }
[01:28:10.163]                   muffleCondition(cond)
[01:28:10.163]                 })
[01:28:10.163]             }))
[01:28:10.163]             future::FutureResult(value = ...future.value$value, 
[01:28:10.163]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.163]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.163]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.163]                     ...future.globalenv.names))
[01:28:10.163]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.163]         }, condition = base::local({
[01:28:10.163]             c <- base::c
[01:28:10.163]             inherits <- base::inherits
[01:28:10.163]             invokeRestart <- base::invokeRestart
[01:28:10.163]             length <- base::length
[01:28:10.163]             list <- base::list
[01:28:10.163]             seq.int <- base::seq.int
[01:28:10.163]             signalCondition <- base::signalCondition
[01:28:10.163]             sys.calls <- base::sys.calls
[01:28:10.163]             `[[` <- base::`[[`
[01:28:10.163]             `+` <- base::`+`
[01:28:10.163]             `<<-` <- base::`<<-`
[01:28:10.163]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.163]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.163]                   3L)]
[01:28:10.163]             }
[01:28:10.163]             function(cond) {
[01:28:10.163]                 is_error <- inherits(cond, "error")
[01:28:10.163]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.163]                   NULL)
[01:28:10.163]                 if (is_error) {
[01:28:10.163]                   sessionInformation <- function() {
[01:28:10.163]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.163]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.163]                       search = base::search(), system = base::Sys.info())
[01:28:10.163]                   }
[01:28:10.163]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.163]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.163]                     cond$call), session = sessionInformation(), 
[01:28:10.163]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.163]                   signalCondition(cond)
[01:28:10.163]                 }
[01:28:10.163]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.163]                 "immediateCondition"))) {
[01:28:10.163]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.163]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.163]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.163]                   if (TRUE && !signal) {
[01:28:10.163]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.163]                     {
[01:28:10.163]                       inherits <- base::inherits
[01:28:10.163]                       invokeRestart <- base::invokeRestart
[01:28:10.163]                       is.null <- base::is.null
[01:28:10.163]                       muffled <- FALSE
[01:28:10.163]                       if (inherits(cond, "message")) {
[01:28:10.163]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.163]                         if (muffled) 
[01:28:10.163]                           invokeRestart("muffleMessage")
[01:28:10.163]                       }
[01:28:10.163]                       else if (inherits(cond, "warning")) {
[01:28:10.163]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.163]                         if (muffled) 
[01:28:10.163]                           invokeRestart("muffleWarning")
[01:28:10.163]                       }
[01:28:10.163]                       else if (inherits(cond, "condition")) {
[01:28:10.163]                         if (!is.null(pattern)) {
[01:28:10.163]                           computeRestarts <- base::computeRestarts
[01:28:10.163]                           grepl <- base::grepl
[01:28:10.163]                           restarts <- computeRestarts(cond)
[01:28:10.163]                           for (restart in restarts) {
[01:28:10.163]                             name <- restart$name
[01:28:10.163]                             if (is.null(name)) 
[01:28:10.163]                               next
[01:28:10.163]                             if (!grepl(pattern, name)) 
[01:28:10.163]                               next
[01:28:10.163]                             invokeRestart(restart)
[01:28:10.163]                             muffled <- TRUE
[01:28:10.163]                             break
[01:28:10.163]                           }
[01:28:10.163]                         }
[01:28:10.163]                       }
[01:28:10.163]                       invisible(muffled)
[01:28:10.163]                     }
[01:28:10.163]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.163]                   }
[01:28:10.163]                 }
[01:28:10.163]                 else {
[01:28:10.163]                   if (TRUE) {
[01:28:10.163]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.163]                     {
[01:28:10.163]                       inherits <- base::inherits
[01:28:10.163]                       invokeRestart <- base::invokeRestart
[01:28:10.163]                       is.null <- base::is.null
[01:28:10.163]                       muffled <- FALSE
[01:28:10.163]                       if (inherits(cond, "message")) {
[01:28:10.163]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.163]                         if (muffled) 
[01:28:10.163]                           invokeRestart("muffleMessage")
[01:28:10.163]                       }
[01:28:10.163]                       else if (inherits(cond, "warning")) {
[01:28:10.163]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.163]                         if (muffled) 
[01:28:10.163]                           invokeRestart("muffleWarning")
[01:28:10.163]                       }
[01:28:10.163]                       else if (inherits(cond, "condition")) {
[01:28:10.163]                         if (!is.null(pattern)) {
[01:28:10.163]                           computeRestarts <- base::computeRestarts
[01:28:10.163]                           grepl <- base::grepl
[01:28:10.163]                           restarts <- computeRestarts(cond)
[01:28:10.163]                           for (restart in restarts) {
[01:28:10.163]                             name <- restart$name
[01:28:10.163]                             if (is.null(name)) 
[01:28:10.163]                               next
[01:28:10.163]                             if (!grepl(pattern, name)) 
[01:28:10.163]                               next
[01:28:10.163]                             invokeRestart(restart)
[01:28:10.163]                             muffled <- TRUE
[01:28:10.163]                             break
[01:28:10.163]                           }
[01:28:10.163]                         }
[01:28:10.163]                       }
[01:28:10.163]                       invisible(muffled)
[01:28:10.163]                     }
[01:28:10.163]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.163]                   }
[01:28:10.163]                 }
[01:28:10.163]             }
[01:28:10.163]         }))
[01:28:10.163]     }, error = function(ex) {
[01:28:10.163]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.163]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.163]                 ...future.rng), started = ...future.startTime, 
[01:28:10.163]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.163]             version = "1.8"), class = "FutureResult")
[01:28:10.163]     }, finally = {
[01:28:10.163]         if (!identical(...future.workdir, getwd())) 
[01:28:10.163]             setwd(...future.workdir)
[01:28:10.163]         {
[01:28:10.163]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.163]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.163]             }
[01:28:10.163]             base::options(...future.oldOptions)
[01:28:10.163]             if (.Platform$OS.type == "windows") {
[01:28:10.163]                 old_names <- names(...future.oldEnvVars)
[01:28:10.163]                 envs <- base::Sys.getenv()
[01:28:10.163]                 names <- names(envs)
[01:28:10.163]                 common <- intersect(names, old_names)
[01:28:10.163]                 added <- setdiff(names, old_names)
[01:28:10.163]                 removed <- setdiff(old_names, names)
[01:28:10.163]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.163]                   envs[common]]
[01:28:10.163]                 NAMES <- toupper(changed)
[01:28:10.163]                 args <- list()
[01:28:10.163]                 for (kk in seq_along(NAMES)) {
[01:28:10.163]                   name <- changed[[kk]]
[01:28:10.163]                   NAME <- NAMES[[kk]]
[01:28:10.163]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.163]                     next
[01:28:10.163]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.163]                 }
[01:28:10.163]                 NAMES <- toupper(added)
[01:28:10.163]                 for (kk in seq_along(NAMES)) {
[01:28:10.163]                   name <- added[[kk]]
[01:28:10.163]                   NAME <- NAMES[[kk]]
[01:28:10.163]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.163]                     next
[01:28:10.163]                   args[[name]] <- ""
[01:28:10.163]                 }
[01:28:10.163]                 NAMES <- toupper(removed)
[01:28:10.163]                 for (kk in seq_along(NAMES)) {
[01:28:10.163]                   name <- removed[[kk]]
[01:28:10.163]                   NAME <- NAMES[[kk]]
[01:28:10.163]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.163]                     next
[01:28:10.163]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.163]                 }
[01:28:10.163]                 if (length(args) > 0) 
[01:28:10.163]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.163]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.163]             }
[01:28:10.163]             else {
[01:28:10.163]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.163]             }
[01:28:10.163]             {
[01:28:10.163]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.163]                   0L) {
[01:28:10.163]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.163]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.163]                   base::options(opts)
[01:28:10.163]                 }
[01:28:10.163]                 {
[01:28:10.163]                   {
[01:28:10.163]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.163]                     NULL
[01:28:10.163]                   }
[01:28:10.163]                   options(future.plan = NULL)
[01:28:10.163]                   if (is.na(NA_character_)) 
[01:28:10.163]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.163]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.163]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.163]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.163]                     envir = parent.frame()) 
[01:28:10.163]                   {
[01:28:10.163]                     if (is.function(workers)) 
[01:28:10.163]                       workers <- workers()
[01:28:10.163]                     workers <- structure(as.integer(workers), 
[01:28:10.163]                       class = class(workers))
[01:28:10.163]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.163]                       workers >= 1)
[01:28:10.163]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.163]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.163]                     }
[01:28:10.163]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.163]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.163]                       envir = envir)
[01:28:10.163]                     if (!future$lazy) 
[01:28:10.163]                       future <- run(future)
[01:28:10.163]                     invisible(future)
[01:28:10.163]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.163]                 }
[01:28:10.163]             }
[01:28:10.163]         }
[01:28:10.163]     })
[01:28:10.163]     if (TRUE) {
[01:28:10.163]         base::sink(type = "output", split = FALSE)
[01:28:10.163]         if (TRUE) {
[01:28:10.163]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.163]         }
[01:28:10.163]         else {
[01:28:10.163]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.163]         }
[01:28:10.163]         base::close(...future.stdout)
[01:28:10.163]         ...future.stdout <- NULL
[01:28:10.163]     }
[01:28:10.163]     ...future.result$conditions <- ...future.conditions
[01:28:10.163]     ...future.result$finished <- base::Sys.time()
[01:28:10.163]     ...future.result
[01:28:10.163] }
[01:28:10.169] Exporting 1 global objects (10.22 KiB) to cluster node #2 ...
[01:28:10.170] Exporting 'a' (10.22 KiB) to cluster node #2 ...
[01:28:10.185] Exporting 'a' (10.22 KiB) to cluster node #2 ... DONE
[01:28:10.185] Exporting 1 global objects (10.22 KiB) to cluster node #2 ... DONE
[01:28:10.186] MultisessionFuture started
[01:28:10.187] - Launch lazy future ... done
[01:28:10.187] run() for 'MultisessionFuture' ... done
[01:28:10.187] result() for ClusterFuture ...
[01:28:10.187] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.188] - Validating connection of MultisessionFuture
[01:28:10.204] - received message: FutureResult
[01:28:10.204] - Received FutureResult
[01:28:10.205] - Erased future from FutureRegistry
[01:28:10.205] result() for ClusterFuture ...
[01:28:10.205] - result already collected: FutureResult
[01:28:10.205] result() for ClusterFuture ... done
[01:28:10.205] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.205] result() for ClusterFuture ... done
[01:28:10.206] result() for ClusterFuture ...
[01:28:10.206] - result already collected: FutureResult
[01:28:10.206] result() for ClusterFuture ... done
value(b) = 2
[01:28:10.206] result() for ClusterFuture ...
[01:28:10.206] - result already collected: FutureResult
[01:28:10.207] result() for ClusterFuture ... done
[01:28:10.207] result() for ClusterFuture ...
[01:28:10.207] - result already collected: FutureResult
[01:28:10.207] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.208] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.208] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:10.209] 
[01:28:10.209] Searching for globals ... DONE
[01:28:10.209] - globals: [0] <none>
[01:28:10.209] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.210] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.210] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:10.211] - globals found: [3] '+', 'value', 'a'
[01:28:10.212] Searching for globals ... DONE
[01:28:10.212] Resolving globals: TRUE
[01:28:10.212] Resolving any globals that are futures ...
[01:28:10.212] - globals: [3] '+', 'value', 'a'
[01:28:10.212] Resolving any globals that are futures ... DONE
[01:28:10.213] Resolving futures part of globals (recursively) ...
[01:28:10.213] resolve() on list ...
[01:28:10.213]  recursive: 99
[01:28:10.214]  length: 1
[01:28:10.214]  elements: 'a'
[01:28:10.214] run() for 'Future' ...
[01:28:10.214] - state: 'created'
[01:28:10.214] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.229] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.229] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.229]   - Field: 'node'
[01:28:10.230]   - Field: 'label'
[01:28:10.230]   - Field: 'local'
[01:28:10.230]   - Field: 'owner'
[01:28:10.230]   - Field: 'envir'
[01:28:10.230]   - Field: 'workers'
[01:28:10.231]   - Field: 'packages'
[01:28:10.231]   - Field: 'gc'
[01:28:10.231]   - Field: 'conditions'
[01:28:10.231]   - Field: 'persistent'
[01:28:10.231]   - Field: 'expr'
[01:28:10.231]   - Field: 'uuid'
[01:28:10.232]   - Field: 'seed'
[01:28:10.232]   - Field: 'version'
[01:28:10.232]   - Field: 'result'
[01:28:10.232]   - Field: 'asynchronous'
[01:28:10.232]   - Field: 'calls'
[01:28:10.233]   - Field: 'globals'
[01:28:10.233]   - Field: 'stdout'
[01:28:10.233]   - Field: 'earlySignal'
[01:28:10.233]   - Field: 'lazy'
[01:28:10.233]   - Field: 'state'
[01:28:10.233] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.234] - Launch lazy future ...
[01:28:10.234] Packages needed by the future expression (n = 0): <none>
[01:28:10.234] Packages needed by future strategies (n = 0): <none>
[01:28:10.235] {
[01:28:10.235]     {
[01:28:10.235]         {
[01:28:10.235]             ...future.startTime <- base::Sys.time()
[01:28:10.235]             {
[01:28:10.235]                 {
[01:28:10.235]                   {
[01:28:10.235]                     {
[01:28:10.235]                       base::local({
[01:28:10.235]                         has_future <- base::requireNamespace("future", 
[01:28:10.235]                           quietly = TRUE)
[01:28:10.235]                         if (has_future) {
[01:28:10.235]                           ns <- base::getNamespace("future")
[01:28:10.235]                           version <- ns[[".package"]][["version"]]
[01:28:10.235]                           if (is.null(version)) 
[01:28:10.235]                             version <- utils::packageVersion("future")
[01:28:10.235]                         }
[01:28:10.235]                         else {
[01:28:10.235]                           version <- NULL
[01:28:10.235]                         }
[01:28:10.235]                         if (!has_future || version < "1.8.0") {
[01:28:10.235]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.235]                             "", base::R.version$version.string), 
[01:28:10.235]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.235]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.235]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.235]                               "release", "version")], collapse = " "), 
[01:28:10.235]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.235]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.235]                             info)
[01:28:10.235]                           info <- base::paste(info, collapse = "; ")
[01:28:10.235]                           if (!has_future) {
[01:28:10.235]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.235]                               info)
[01:28:10.235]                           }
[01:28:10.235]                           else {
[01:28:10.235]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.235]                               info, version)
[01:28:10.235]                           }
[01:28:10.235]                           base::stop(msg)
[01:28:10.235]                         }
[01:28:10.235]                       })
[01:28:10.235]                     }
[01:28:10.235]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.235]                     base::options(mc.cores = 1L)
[01:28:10.235]                   }
[01:28:10.235]                   options(future.plan = NULL)
[01:28:10.235]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.235]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.235]                 }
[01:28:10.235]                 ...future.workdir <- getwd()
[01:28:10.235]             }
[01:28:10.235]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.235]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.235]         }
[01:28:10.235]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.235]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:10.235]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.235]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.235]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.235]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.235]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.235]             base::names(...future.oldOptions))
[01:28:10.235]     }
[01:28:10.235]     if (FALSE) {
[01:28:10.235]     }
[01:28:10.235]     else {
[01:28:10.235]         if (TRUE) {
[01:28:10.235]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.235]                 open = "w")
[01:28:10.235]         }
[01:28:10.235]         else {
[01:28:10.235]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.235]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.235]         }
[01:28:10.235]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.235]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.235]             base::sink(type = "output", split = FALSE)
[01:28:10.235]             base::close(...future.stdout)
[01:28:10.235]         }, add = TRUE)
[01:28:10.235]     }
[01:28:10.235]     ...future.frame <- base::sys.nframe()
[01:28:10.235]     ...future.conditions <- base::list()
[01:28:10.235]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.235]     if (FALSE) {
[01:28:10.235]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.235]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.235]     }
[01:28:10.235]     ...future.result <- base::tryCatch({
[01:28:10.235]         base::withCallingHandlers({
[01:28:10.235]             ...future.value <- base::withVisible(base::local({
[01:28:10.235]                 ...future.makeSendCondition <- base::local({
[01:28:10.235]                   sendCondition <- NULL
[01:28:10.235]                   function(frame = 1L) {
[01:28:10.235]                     if (is.function(sendCondition)) 
[01:28:10.235]                       return(sendCondition)
[01:28:10.235]                     ns <- getNamespace("parallel")
[01:28:10.235]                     if (exists("sendData", mode = "function", 
[01:28:10.235]                       envir = ns)) {
[01:28:10.235]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.235]                         envir = ns)
[01:28:10.235]                       envir <- sys.frame(frame)
[01:28:10.235]                       master <- NULL
[01:28:10.235]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.235]                         !identical(envir, emptyenv())) {
[01:28:10.235]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.235]                           inherits = FALSE)) {
[01:28:10.235]                           master <- get("master", mode = "list", 
[01:28:10.235]                             envir = envir, inherits = FALSE)
[01:28:10.235]                           if (inherits(master, c("SOCKnode", 
[01:28:10.235]                             "SOCK0node"))) {
[01:28:10.235]                             sendCondition <<- function(cond) {
[01:28:10.235]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.235]                                 success = TRUE)
[01:28:10.235]                               parallel_sendData(master, data)
[01:28:10.235]                             }
[01:28:10.235]                             return(sendCondition)
[01:28:10.235]                           }
[01:28:10.235]                         }
[01:28:10.235]                         frame <- frame + 1L
[01:28:10.235]                         envir <- sys.frame(frame)
[01:28:10.235]                       }
[01:28:10.235]                     }
[01:28:10.235]                     sendCondition <<- function(cond) NULL
[01:28:10.235]                   }
[01:28:10.235]                 })
[01:28:10.235]                 withCallingHandlers({
[01:28:10.235]                   1
[01:28:10.235]                 }, immediateCondition = function(cond) {
[01:28:10.235]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.235]                   sendCondition(cond)
[01:28:10.235]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.235]                   {
[01:28:10.235]                     inherits <- base::inherits
[01:28:10.235]                     invokeRestart <- base::invokeRestart
[01:28:10.235]                     is.null <- base::is.null
[01:28:10.235]                     muffled <- FALSE
[01:28:10.235]                     if (inherits(cond, "message")) {
[01:28:10.235]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.235]                       if (muffled) 
[01:28:10.235]                         invokeRestart("muffleMessage")
[01:28:10.235]                     }
[01:28:10.235]                     else if (inherits(cond, "warning")) {
[01:28:10.235]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.235]                       if (muffled) 
[01:28:10.235]                         invokeRestart("muffleWarning")
[01:28:10.235]                     }
[01:28:10.235]                     else if (inherits(cond, "condition")) {
[01:28:10.235]                       if (!is.null(pattern)) {
[01:28:10.235]                         computeRestarts <- base::computeRestarts
[01:28:10.235]                         grepl <- base::grepl
[01:28:10.235]                         restarts <- computeRestarts(cond)
[01:28:10.235]                         for (restart in restarts) {
[01:28:10.235]                           name <- restart$name
[01:28:10.235]                           if (is.null(name)) 
[01:28:10.235]                             next
[01:28:10.235]                           if (!grepl(pattern, name)) 
[01:28:10.235]                             next
[01:28:10.235]                           invokeRestart(restart)
[01:28:10.235]                           muffled <- TRUE
[01:28:10.235]                           break
[01:28:10.235]                         }
[01:28:10.235]                       }
[01:28:10.235]                     }
[01:28:10.235]                     invisible(muffled)
[01:28:10.235]                   }
[01:28:10.235]                   muffleCondition(cond)
[01:28:10.235]                 })
[01:28:10.235]             }))
[01:28:10.235]             future::FutureResult(value = ...future.value$value, 
[01:28:10.235]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.235]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.235]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.235]                     ...future.globalenv.names))
[01:28:10.235]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.235]         }, condition = base::local({
[01:28:10.235]             c <- base::c
[01:28:10.235]             inherits <- base::inherits
[01:28:10.235]             invokeRestart <- base::invokeRestart
[01:28:10.235]             length <- base::length
[01:28:10.235]             list <- base::list
[01:28:10.235]             seq.int <- base::seq.int
[01:28:10.235]             signalCondition <- base::signalCondition
[01:28:10.235]             sys.calls <- base::sys.calls
[01:28:10.235]             `[[` <- base::`[[`
[01:28:10.235]             `+` <- base::`+`
[01:28:10.235]             `<<-` <- base::`<<-`
[01:28:10.235]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.235]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.235]                   3L)]
[01:28:10.235]             }
[01:28:10.235]             function(cond) {
[01:28:10.235]                 is_error <- inherits(cond, "error")
[01:28:10.235]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.235]                   NULL)
[01:28:10.235]                 if (is_error) {
[01:28:10.235]                   sessionInformation <- function() {
[01:28:10.235]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.235]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.235]                       search = base::search(), system = base::Sys.info())
[01:28:10.235]                   }
[01:28:10.235]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.235]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.235]                     cond$call), session = sessionInformation(), 
[01:28:10.235]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.235]                   signalCondition(cond)
[01:28:10.235]                 }
[01:28:10.235]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.235]                 "immediateCondition"))) {
[01:28:10.235]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.235]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.235]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.235]                   if (TRUE && !signal) {
[01:28:10.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.235]                     {
[01:28:10.235]                       inherits <- base::inherits
[01:28:10.235]                       invokeRestart <- base::invokeRestart
[01:28:10.235]                       is.null <- base::is.null
[01:28:10.235]                       muffled <- FALSE
[01:28:10.235]                       if (inherits(cond, "message")) {
[01:28:10.235]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.235]                         if (muffled) 
[01:28:10.235]                           invokeRestart("muffleMessage")
[01:28:10.235]                       }
[01:28:10.235]                       else if (inherits(cond, "warning")) {
[01:28:10.235]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.235]                         if (muffled) 
[01:28:10.235]                           invokeRestart("muffleWarning")
[01:28:10.235]                       }
[01:28:10.235]                       else if (inherits(cond, "condition")) {
[01:28:10.235]                         if (!is.null(pattern)) {
[01:28:10.235]                           computeRestarts <- base::computeRestarts
[01:28:10.235]                           grepl <- base::grepl
[01:28:10.235]                           restarts <- computeRestarts(cond)
[01:28:10.235]                           for (restart in restarts) {
[01:28:10.235]                             name <- restart$name
[01:28:10.235]                             if (is.null(name)) 
[01:28:10.235]                               next
[01:28:10.235]                             if (!grepl(pattern, name)) 
[01:28:10.235]                               next
[01:28:10.235]                             invokeRestart(restart)
[01:28:10.235]                             muffled <- TRUE
[01:28:10.235]                             break
[01:28:10.235]                           }
[01:28:10.235]                         }
[01:28:10.235]                       }
[01:28:10.235]                       invisible(muffled)
[01:28:10.235]                     }
[01:28:10.235]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.235]                   }
[01:28:10.235]                 }
[01:28:10.235]                 else {
[01:28:10.235]                   if (TRUE) {
[01:28:10.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.235]                     {
[01:28:10.235]                       inherits <- base::inherits
[01:28:10.235]                       invokeRestart <- base::invokeRestart
[01:28:10.235]                       is.null <- base::is.null
[01:28:10.235]                       muffled <- FALSE
[01:28:10.235]                       if (inherits(cond, "message")) {
[01:28:10.235]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.235]                         if (muffled) 
[01:28:10.235]                           invokeRestart("muffleMessage")
[01:28:10.235]                       }
[01:28:10.235]                       else if (inherits(cond, "warning")) {
[01:28:10.235]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.235]                         if (muffled) 
[01:28:10.235]                           invokeRestart("muffleWarning")
[01:28:10.235]                       }
[01:28:10.235]                       else if (inherits(cond, "condition")) {
[01:28:10.235]                         if (!is.null(pattern)) {
[01:28:10.235]                           computeRestarts <- base::computeRestarts
[01:28:10.235]                           grepl <- base::grepl
[01:28:10.235]                           restarts <- computeRestarts(cond)
[01:28:10.235]                           for (restart in restarts) {
[01:28:10.235]                             name <- restart$name
[01:28:10.235]                             if (is.null(name)) 
[01:28:10.235]                               next
[01:28:10.235]                             if (!grepl(pattern, name)) 
[01:28:10.235]                               next
[01:28:10.235]                             invokeRestart(restart)
[01:28:10.235]                             muffled <- TRUE
[01:28:10.235]                             break
[01:28:10.235]                           }
[01:28:10.235]                         }
[01:28:10.235]                       }
[01:28:10.235]                       invisible(muffled)
[01:28:10.235]                     }
[01:28:10.235]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.235]                   }
[01:28:10.235]                 }
[01:28:10.235]             }
[01:28:10.235]         }))
[01:28:10.235]     }, error = function(ex) {
[01:28:10.235]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.235]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.235]                 ...future.rng), started = ...future.startTime, 
[01:28:10.235]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.235]             version = "1.8"), class = "FutureResult")
[01:28:10.235]     }, finally = {
[01:28:10.235]         if (!identical(...future.workdir, getwd())) 
[01:28:10.235]             setwd(...future.workdir)
[01:28:10.235]         {
[01:28:10.235]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.235]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.235]             }
[01:28:10.235]             base::options(...future.oldOptions)
[01:28:10.235]             if (.Platform$OS.type == "windows") {
[01:28:10.235]                 old_names <- names(...future.oldEnvVars)
[01:28:10.235]                 envs <- base::Sys.getenv()
[01:28:10.235]                 names <- names(envs)
[01:28:10.235]                 common <- intersect(names, old_names)
[01:28:10.235]                 added <- setdiff(names, old_names)
[01:28:10.235]                 removed <- setdiff(old_names, names)
[01:28:10.235]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.235]                   envs[common]]
[01:28:10.235]                 NAMES <- toupper(changed)
[01:28:10.235]                 args <- list()
[01:28:10.235]                 for (kk in seq_along(NAMES)) {
[01:28:10.235]                   name <- changed[[kk]]
[01:28:10.235]                   NAME <- NAMES[[kk]]
[01:28:10.235]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.235]                     next
[01:28:10.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.235]                 }
[01:28:10.235]                 NAMES <- toupper(added)
[01:28:10.235]                 for (kk in seq_along(NAMES)) {
[01:28:10.235]                   name <- added[[kk]]
[01:28:10.235]                   NAME <- NAMES[[kk]]
[01:28:10.235]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.235]                     next
[01:28:10.235]                   args[[name]] <- ""
[01:28:10.235]                 }
[01:28:10.235]                 NAMES <- toupper(removed)
[01:28:10.235]                 for (kk in seq_along(NAMES)) {
[01:28:10.235]                   name <- removed[[kk]]
[01:28:10.235]                   NAME <- NAMES[[kk]]
[01:28:10.235]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.235]                     next
[01:28:10.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.235]                 }
[01:28:10.235]                 if (length(args) > 0) 
[01:28:10.235]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.235]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.235]             }
[01:28:10.235]             else {
[01:28:10.235]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.235]             }
[01:28:10.235]             {
[01:28:10.235]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.235]                   0L) {
[01:28:10.235]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.235]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.235]                   base::options(opts)
[01:28:10.235]                 }
[01:28:10.235]                 {
[01:28:10.235]                   {
[01:28:10.235]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.235]                     NULL
[01:28:10.235]                   }
[01:28:10.235]                   options(future.plan = NULL)
[01:28:10.235]                   if (is.na(NA_character_)) 
[01:28:10.235]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.235]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.235]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.235]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.235]                     envir = parent.frame()) 
[01:28:10.235]                   {
[01:28:10.235]                     if (is.function(workers)) 
[01:28:10.235]                       workers <- workers()
[01:28:10.235]                     workers <- structure(as.integer(workers), 
[01:28:10.235]                       class = class(workers))
[01:28:10.235]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.235]                       workers >= 1)
[01:28:10.235]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.235]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.235]                     }
[01:28:10.235]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.235]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.235]                       envir = envir)
[01:28:10.235]                     if (!future$lazy) 
[01:28:10.235]                       future <- run(future)
[01:28:10.235]                     invisible(future)
[01:28:10.235]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.235]                 }
[01:28:10.235]             }
[01:28:10.235]         }
[01:28:10.235]     })
[01:28:10.235]     if (TRUE) {
[01:28:10.235]         base::sink(type = "output", split = FALSE)
[01:28:10.235]         if (TRUE) {
[01:28:10.235]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.235]         }
[01:28:10.235]         else {
[01:28:10.235]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.235]         }
[01:28:10.235]         base::close(...future.stdout)
[01:28:10.235]         ...future.stdout <- NULL
[01:28:10.235]     }
[01:28:10.235]     ...future.result$conditions <- ...future.conditions
[01:28:10.235]     ...future.result$finished <- base::Sys.time()
[01:28:10.235]     ...future.result
[01:28:10.235] }
[01:28:10.241] MultisessionFuture started
[01:28:10.241] - Launch lazy future ... done
[01:28:10.241] run() for 'MultisessionFuture' ... done
[01:28:10.259] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.259] - Validating connection of MultisessionFuture
[01:28:10.260] - received message: FutureResult
[01:28:10.260] - Received FutureResult
[01:28:10.260] - Erased future from FutureRegistry
[01:28:10.260] result() for ClusterFuture ...
[01:28:10.260] - result already collected: FutureResult
[01:28:10.261] result() for ClusterFuture ... done
[01:28:10.261] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.261] Future #1
[01:28:10.261] result() for ClusterFuture ...
[01:28:10.261] - result already collected: FutureResult
[01:28:10.261] result() for ClusterFuture ... done
[01:28:10.262] result() for ClusterFuture ...
[01:28:10.262] - result already collected: FutureResult
[01:28:10.262] result() for ClusterFuture ... done
[01:28:10.262] A MultisessionFuture was resolved
[01:28:10.262]  length: 0 (resolved future 1)
[01:28:10.262] resolve() on list ... DONE
[01:28:10.263] - globals: [1] 'a'
[01:28:10.263] Resolving futures part of globals (recursively) ... DONE
[01:28:10.264] The total size of the 1 globals is 10.22 KiB (10464 bytes)
[01:28:10.265] The total size of the 1 globals exported for future expression ('value(a) + 1') is 10.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (10.22 KiB of class 'environment')
[01:28:10.265] - globals: [1] 'a'
[01:28:10.265] - packages: [1] 'future'
[01:28:10.265] getGlobalsAndPackages() ... DONE
[01:28:10.266] run() for 'Future' ...
[01:28:10.266] - state: 'created'
[01:28:10.266] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.282] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.283]   - Field: 'node'
[01:28:10.283]   - Field: 'label'
[01:28:10.283]   - Field: 'local'
[01:28:10.283]   - Field: 'owner'
[01:28:10.284]   - Field: 'envir'
[01:28:10.284]   - Field: 'workers'
[01:28:10.284]   - Field: 'packages'
[01:28:10.284]   - Field: 'gc'
[01:28:10.284]   - Field: 'conditions'
[01:28:10.284]   - Field: 'persistent'
[01:28:10.285]   - Field: 'expr'
[01:28:10.285]   - Field: 'uuid'
[01:28:10.285]   - Field: 'seed'
[01:28:10.285]   - Field: 'version'
[01:28:10.285]   - Field: 'result'
[01:28:10.286]   - Field: 'asynchronous'
[01:28:10.286]   - Field: 'calls'
[01:28:10.286]   - Field: 'globals'
[01:28:10.286]   - Field: 'stdout'
[01:28:10.286]   - Field: 'earlySignal'
[01:28:10.286]   - Field: 'lazy'
[01:28:10.287]   - Field: 'state'
[01:28:10.287] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.287] - Launch lazy future ...
[01:28:10.287] Packages needed by the future expression (n = 1): 'future'
[01:28:10.288] Packages needed by future strategies (n = 0): <none>
[01:28:10.289] {
[01:28:10.289]     {
[01:28:10.289]         {
[01:28:10.289]             ...future.startTime <- base::Sys.time()
[01:28:10.289]             {
[01:28:10.289]                 {
[01:28:10.289]                   {
[01:28:10.289]                     {
[01:28:10.289]                       {
[01:28:10.289]                         base::local({
[01:28:10.289]                           has_future <- base::requireNamespace("future", 
[01:28:10.289]                             quietly = TRUE)
[01:28:10.289]                           if (has_future) {
[01:28:10.289]                             ns <- base::getNamespace("future")
[01:28:10.289]                             version <- ns[[".package"]][["version"]]
[01:28:10.289]                             if (is.null(version)) 
[01:28:10.289]                               version <- utils::packageVersion("future")
[01:28:10.289]                           }
[01:28:10.289]                           else {
[01:28:10.289]                             version <- NULL
[01:28:10.289]                           }
[01:28:10.289]                           if (!has_future || version < "1.8.0") {
[01:28:10.289]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.289]                               "", base::R.version$version.string), 
[01:28:10.289]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:10.289]                                 base::R.version$platform, 8 * 
[01:28:10.289]                                   base::.Machine$sizeof.pointer), 
[01:28:10.289]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.289]                                 "release", "version")], collapse = " "), 
[01:28:10.289]                               hostname = base::Sys.info()[["nodename"]])
[01:28:10.289]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.289]                               info)
[01:28:10.289]                             info <- base::paste(info, collapse = "; ")
[01:28:10.289]                             if (!has_future) {
[01:28:10.289]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.289]                                 info)
[01:28:10.289]                             }
[01:28:10.289]                             else {
[01:28:10.289]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.289]                                 info, version)
[01:28:10.289]                             }
[01:28:10.289]                             base::stop(msg)
[01:28:10.289]                           }
[01:28:10.289]                         })
[01:28:10.289]                       }
[01:28:10.289]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.289]                       base::options(mc.cores = 1L)
[01:28:10.289]                     }
[01:28:10.289]                     base::local({
[01:28:10.289]                       for (pkg in "future") {
[01:28:10.289]                         base::loadNamespace(pkg)
[01:28:10.289]                         base::library(pkg, character.only = TRUE)
[01:28:10.289]                       }
[01:28:10.289]                     })
[01:28:10.289]                   }
[01:28:10.289]                   options(future.plan = NULL)
[01:28:10.289]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.289]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.289]                 }
[01:28:10.289]                 ...future.workdir <- getwd()
[01:28:10.289]             }
[01:28:10.289]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.289]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.289]         }
[01:28:10.289]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.289]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:10.289]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.289]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.289]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.289]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.289]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.289]             base::names(...future.oldOptions))
[01:28:10.289]     }
[01:28:10.289]     if (FALSE) {
[01:28:10.289]     }
[01:28:10.289]     else {
[01:28:10.289]         if (TRUE) {
[01:28:10.289]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.289]                 open = "w")
[01:28:10.289]         }
[01:28:10.289]         else {
[01:28:10.289]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.289]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.289]         }
[01:28:10.289]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.289]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.289]             base::sink(type = "output", split = FALSE)
[01:28:10.289]             base::close(...future.stdout)
[01:28:10.289]         }, add = TRUE)
[01:28:10.289]     }
[01:28:10.289]     ...future.frame <- base::sys.nframe()
[01:28:10.289]     ...future.conditions <- base::list()
[01:28:10.289]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.289]     if (FALSE) {
[01:28:10.289]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.289]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.289]     }
[01:28:10.289]     ...future.result <- base::tryCatch({
[01:28:10.289]         base::withCallingHandlers({
[01:28:10.289]             ...future.value <- base::withVisible(base::local({
[01:28:10.289]                 ...future.makeSendCondition <- base::local({
[01:28:10.289]                   sendCondition <- NULL
[01:28:10.289]                   function(frame = 1L) {
[01:28:10.289]                     if (is.function(sendCondition)) 
[01:28:10.289]                       return(sendCondition)
[01:28:10.289]                     ns <- getNamespace("parallel")
[01:28:10.289]                     if (exists("sendData", mode = "function", 
[01:28:10.289]                       envir = ns)) {
[01:28:10.289]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.289]                         envir = ns)
[01:28:10.289]                       envir <- sys.frame(frame)
[01:28:10.289]                       master <- NULL
[01:28:10.289]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.289]                         !identical(envir, emptyenv())) {
[01:28:10.289]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.289]                           inherits = FALSE)) {
[01:28:10.289]                           master <- get("master", mode = "list", 
[01:28:10.289]                             envir = envir, inherits = FALSE)
[01:28:10.289]                           if (inherits(master, c("SOCKnode", 
[01:28:10.289]                             "SOCK0node"))) {
[01:28:10.289]                             sendCondition <<- function(cond) {
[01:28:10.289]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.289]                                 success = TRUE)
[01:28:10.289]                               parallel_sendData(master, data)
[01:28:10.289]                             }
[01:28:10.289]                             return(sendCondition)
[01:28:10.289]                           }
[01:28:10.289]                         }
[01:28:10.289]                         frame <- frame + 1L
[01:28:10.289]                         envir <- sys.frame(frame)
[01:28:10.289]                       }
[01:28:10.289]                     }
[01:28:10.289]                     sendCondition <<- function(cond) NULL
[01:28:10.289]                   }
[01:28:10.289]                 })
[01:28:10.289]                 withCallingHandlers({
[01:28:10.289]                   value(a) + 1
[01:28:10.289]                 }, immediateCondition = function(cond) {
[01:28:10.289]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.289]                   sendCondition(cond)
[01:28:10.289]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.289]                   {
[01:28:10.289]                     inherits <- base::inherits
[01:28:10.289]                     invokeRestart <- base::invokeRestart
[01:28:10.289]                     is.null <- base::is.null
[01:28:10.289]                     muffled <- FALSE
[01:28:10.289]                     if (inherits(cond, "message")) {
[01:28:10.289]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.289]                       if (muffled) 
[01:28:10.289]                         invokeRestart("muffleMessage")
[01:28:10.289]                     }
[01:28:10.289]                     else if (inherits(cond, "warning")) {
[01:28:10.289]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.289]                       if (muffled) 
[01:28:10.289]                         invokeRestart("muffleWarning")
[01:28:10.289]                     }
[01:28:10.289]                     else if (inherits(cond, "condition")) {
[01:28:10.289]                       if (!is.null(pattern)) {
[01:28:10.289]                         computeRestarts <- base::computeRestarts
[01:28:10.289]                         grepl <- base::grepl
[01:28:10.289]                         restarts <- computeRestarts(cond)
[01:28:10.289]                         for (restart in restarts) {
[01:28:10.289]                           name <- restart$name
[01:28:10.289]                           if (is.null(name)) 
[01:28:10.289]                             next
[01:28:10.289]                           if (!grepl(pattern, name)) 
[01:28:10.289]                             next
[01:28:10.289]                           invokeRestart(restart)
[01:28:10.289]                           muffled <- TRUE
[01:28:10.289]                           break
[01:28:10.289]                         }
[01:28:10.289]                       }
[01:28:10.289]                     }
[01:28:10.289]                     invisible(muffled)
[01:28:10.289]                   }
[01:28:10.289]                   muffleCondition(cond)
[01:28:10.289]                 })
[01:28:10.289]             }))
[01:28:10.289]             future::FutureResult(value = ...future.value$value, 
[01:28:10.289]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.289]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.289]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.289]                     ...future.globalenv.names))
[01:28:10.289]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.289]         }, condition = base::local({
[01:28:10.289]             c <- base::c
[01:28:10.289]             inherits <- base::inherits
[01:28:10.289]             invokeRestart <- base::invokeRestart
[01:28:10.289]             length <- base::length
[01:28:10.289]             list <- base::list
[01:28:10.289]             seq.int <- base::seq.int
[01:28:10.289]             signalCondition <- base::signalCondition
[01:28:10.289]             sys.calls <- base::sys.calls
[01:28:10.289]             `[[` <- base::`[[`
[01:28:10.289]             `+` <- base::`+`
[01:28:10.289]             `<<-` <- base::`<<-`
[01:28:10.289]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.289]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.289]                   3L)]
[01:28:10.289]             }
[01:28:10.289]             function(cond) {
[01:28:10.289]                 is_error <- inherits(cond, "error")
[01:28:10.289]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.289]                   NULL)
[01:28:10.289]                 if (is_error) {
[01:28:10.289]                   sessionInformation <- function() {
[01:28:10.289]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.289]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.289]                       search = base::search(), system = base::Sys.info())
[01:28:10.289]                   }
[01:28:10.289]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.289]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.289]                     cond$call), session = sessionInformation(), 
[01:28:10.289]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.289]                   signalCondition(cond)
[01:28:10.289]                 }
[01:28:10.289]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.289]                 "immediateCondition"))) {
[01:28:10.289]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.289]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.289]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.289]                   if (TRUE && !signal) {
[01:28:10.289]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.289]                     {
[01:28:10.289]                       inherits <- base::inherits
[01:28:10.289]                       invokeRestart <- base::invokeRestart
[01:28:10.289]                       is.null <- base::is.null
[01:28:10.289]                       muffled <- FALSE
[01:28:10.289]                       if (inherits(cond, "message")) {
[01:28:10.289]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.289]                         if (muffled) 
[01:28:10.289]                           invokeRestart("muffleMessage")
[01:28:10.289]                       }
[01:28:10.289]                       else if (inherits(cond, "warning")) {
[01:28:10.289]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.289]                         if (muffled) 
[01:28:10.289]                           invokeRestart("muffleWarning")
[01:28:10.289]                       }
[01:28:10.289]                       else if (inherits(cond, "condition")) {
[01:28:10.289]                         if (!is.null(pattern)) {
[01:28:10.289]                           computeRestarts <- base::computeRestarts
[01:28:10.289]                           grepl <- base::grepl
[01:28:10.289]                           restarts <- computeRestarts(cond)
[01:28:10.289]                           for (restart in restarts) {
[01:28:10.289]                             name <- restart$name
[01:28:10.289]                             if (is.null(name)) 
[01:28:10.289]                               next
[01:28:10.289]                             if (!grepl(pattern, name)) 
[01:28:10.289]                               next
[01:28:10.289]                             invokeRestart(restart)
[01:28:10.289]                             muffled <- TRUE
[01:28:10.289]                             break
[01:28:10.289]                           }
[01:28:10.289]                         }
[01:28:10.289]                       }
[01:28:10.289]                       invisible(muffled)
[01:28:10.289]                     }
[01:28:10.289]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.289]                   }
[01:28:10.289]                 }
[01:28:10.289]                 else {
[01:28:10.289]                   if (TRUE) {
[01:28:10.289]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.289]                     {
[01:28:10.289]                       inherits <- base::inherits
[01:28:10.289]                       invokeRestart <- base::invokeRestart
[01:28:10.289]                       is.null <- base::is.null
[01:28:10.289]                       muffled <- FALSE
[01:28:10.289]                       if (inherits(cond, "message")) {
[01:28:10.289]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.289]                         if (muffled) 
[01:28:10.289]                           invokeRestart("muffleMessage")
[01:28:10.289]                       }
[01:28:10.289]                       else if (inherits(cond, "warning")) {
[01:28:10.289]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.289]                         if (muffled) 
[01:28:10.289]                           invokeRestart("muffleWarning")
[01:28:10.289]                       }
[01:28:10.289]                       else if (inherits(cond, "condition")) {
[01:28:10.289]                         if (!is.null(pattern)) {
[01:28:10.289]                           computeRestarts <- base::computeRestarts
[01:28:10.289]                           grepl <- base::grepl
[01:28:10.289]                           restarts <- computeRestarts(cond)
[01:28:10.289]                           for (restart in restarts) {
[01:28:10.289]                             name <- restart$name
[01:28:10.289]                             if (is.null(name)) 
[01:28:10.289]                               next
[01:28:10.289]                             if (!grepl(pattern, name)) 
[01:28:10.289]                               next
[01:28:10.289]                             invokeRestart(restart)
[01:28:10.289]                             muffled <- TRUE
[01:28:10.289]                             break
[01:28:10.289]                           }
[01:28:10.289]                         }
[01:28:10.289]                       }
[01:28:10.289]                       invisible(muffled)
[01:28:10.289]                     }
[01:28:10.289]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.289]                   }
[01:28:10.289]                 }
[01:28:10.289]             }
[01:28:10.289]         }))
[01:28:10.289]     }, error = function(ex) {
[01:28:10.289]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.289]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.289]                 ...future.rng), started = ...future.startTime, 
[01:28:10.289]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.289]             version = "1.8"), class = "FutureResult")
[01:28:10.289]     }, finally = {
[01:28:10.289]         if (!identical(...future.workdir, getwd())) 
[01:28:10.289]             setwd(...future.workdir)
[01:28:10.289]         {
[01:28:10.289]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.289]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.289]             }
[01:28:10.289]             base::options(...future.oldOptions)
[01:28:10.289]             if (.Platform$OS.type == "windows") {
[01:28:10.289]                 old_names <- names(...future.oldEnvVars)
[01:28:10.289]                 envs <- base::Sys.getenv()
[01:28:10.289]                 names <- names(envs)
[01:28:10.289]                 common <- intersect(names, old_names)
[01:28:10.289]                 added <- setdiff(names, old_names)
[01:28:10.289]                 removed <- setdiff(old_names, names)
[01:28:10.289]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.289]                   envs[common]]
[01:28:10.289]                 NAMES <- toupper(changed)
[01:28:10.289]                 args <- list()
[01:28:10.289]                 for (kk in seq_along(NAMES)) {
[01:28:10.289]                   name <- changed[[kk]]
[01:28:10.289]                   NAME <- NAMES[[kk]]
[01:28:10.289]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.289]                     next
[01:28:10.289]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.289]                 }
[01:28:10.289]                 NAMES <- toupper(added)
[01:28:10.289]                 for (kk in seq_along(NAMES)) {
[01:28:10.289]                   name <- added[[kk]]
[01:28:10.289]                   NAME <- NAMES[[kk]]
[01:28:10.289]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.289]                     next
[01:28:10.289]                   args[[name]] <- ""
[01:28:10.289]                 }
[01:28:10.289]                 NAMES <- toupper(removed)
[01:28:10.289]                 for (kk in seq_along(NAMES)) {
[01:28:10.289]                   name <- removed[[kk]]
[01:28:10.289]                   NAME <- NAMES[[kk]]
[01:28:10.289]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.289]                     next
[01:28:10.289]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.289]                 }
[01:28:10.289]                 if (length(args) > 0) 
[01:28:10.289]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.289]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.289]             }
[01:28:10.289]             else {
[01:28:10.289]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.289]             }
[01:28:10.289]             {
[01:28:10.289]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.289]                   0L) {
[01:28:10.289]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.289]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.289]                   base::options(opts)
[01:28:10.289]                 }
[01:28:10.289]                 {
[01:28:10.289]                   {
[01:28:10.289]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.289]                     NULL
[01:28:10.289]                   }
[01:28:10.289]                   options(future.plan = NULL)
[01:28:10.289]                   if (is.na(NA_character_)) 
[01:28:10.289]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.289]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.289]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.289]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.289]                     envir = parent.frame()) 
[01:28:10.289]                   {
[01:28:10.289]                     if (is.function(workers)) 
[01:28:10.289]                       workers <- workers()
[01:28:10.289]                     workers <- structure(as.integer(workers), 
[01:28:10.289]                       class = class(workers))
[01:28:10.289]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.289]                       workers >= 1)
[01:28:10.289]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.289]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.289]                     }
[01:28:10.289]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.289]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.289]                       envir = envir)
[01:28:10.289]                     if (!future$lazy) 
[01:28:10.289]                       future <- run(future)
[01:28:10.289]                     invisible(future)
[01:28:10.289]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.289]                 }
[01:28:10.289]             }
[01:28:10.289]         }
[01:28:10.289]     })
[01:28:10.289]     if (TRUE) {
[01:28:10.289]         base::sink(type = "output", split = FALSE)
[01:28:10.289]         if (TRUE) {
[01:28:10.289]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.289]         }
[01:28:10.289]         else {
[01:28:10.289]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.289]         }
[01:28:10.289]         base::close(...future.stdout)
[01:28:10.289]         ...future.stdout <- NULL
[01:28:10.289]     }
[01:28:10.289]     ...future.result$conditions <- ...future.conditions
[01:28:10.289]     ...future.result$finished <- base::Sys.time()
[01:28:10.289]     ...future.result
[01:28:10.289] }
[01:28:10.295] Exporting 1 global objects (10.22 KiB) to cluster node #2 ...
[01:28:10.296] Exporting 'a' (10.22 KiB) to cluster node #2 ...
[01:28:10.308] Exporting 'a' (10.22 KiB) to cluster node #2 ... DONE
[01:28:10.309] Exporting 1 global objects (10.22 KiB) to cluster node #2 ... DONE
[01:28:10.310] MultisessionFuture started
[01:28:10.310] - Launch lazy future ... done
[01:28:10.310] run() for 'MultisessionFuture' ... done
[01:28:10.311] result() for ClusterFuture ...
[01:28:10.311] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.311] - Validating connection of MultisessionFuture
[01:28:10.331] - received message: FutureResult
[01:28:10.331] - Received FutureResult
[01:28:10.332] - Erased future from FutureRegistry
[01:28:10.332] result() for ClusterFuture ...
[01:28:10.332] - result already collected: FutureResult
[01:28:10.332] result() for ClusterFuture ... done
[01:28:10.332] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.332] result() for ClusterFuture ... done
[01:28:10.333] result() for ClusterFuture ...
[01:28:10.333] - result already collected: FutureResult
[01:28:10.333] result() for ClusterFuture ... done
value(b) = 2
[01:28:10.333] result() for ClusterFuture ...
[01:28:10.333] - result already collected: FutureResult
[01:28:10.334] result() for ClusterFuture ... done
[01:28:10.334] result() for ClusterFuture ...
[01:28:10.334] - result already collected: FutureResult
[01:28:10.334] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.334] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.335] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'conservative'
[01:28:10.336] - globals found: [2] '{', 'pkg'
[01:28:10.336] Searching for globals ... DONE
[01:28:10.336] Resolving globals: TRUE
[01:28:10.337] Resolving any globals that are futures ...
[01:28:10.337] - globals: [2] '{', 'pkg'
[01:28:10.337] Resolving any globals that are futures ... DONE
[01:28:10.337] Resolving futures part of globals (recursively) ...
[01:28:10.338] resolve() on list ...
[01:28:10.338]  recursive: 99
[01:28:10.338]  length: 1
[01:28:10.338]  elements: 'pkg'
[01:28:10.338]  length: 0 (resolved future 1)
[01:28:10.339] resolve() on list ... DONE
[01:28:10.339] - globals: [1] 'pkg'
[01:28:10.339] Resolving futures part of globals (recursively) ... DONE
[01:28:10.339] The total size of the 1 globals is 112 bytes (112 bytes)
[01:28:10.340] The total size of the 1 globals exported for future expression ('{; pkg; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'pkg' (112 bytes of class 'character')
[01:28:10.340] - globals: [1] 'pkg'
[01:28:10.340] 
[01:28:10.340] getGlobalsAndPackages() ... DONE
[01:28:10.341] Packages needed by the future expression (n = 0): <none>
[01:28:10.341] Packages needed by future strategies (n = 0): <none>
[01:28:10.342] {
[01:28:10.342]     {
[01:28:10.342]         {
[01:28:10.342]             ...future.startTime <- base::Sys.time()
[01:28:10.342]             {
[01:28:10.342]                 {
[01:28:10.342]                   {
[01:28:10.342]                     base::local({
[01:28:10.342]                       has_future <- base::requireNamespace("future", 
[01:28:10.342]                         quietly = TRUE)
[01:28:10.342]                       if (has_future) {
[01:28:10.342]                         ns <- base::getNamespace("future")
[01:28:10.342]                         version <- ns[[".package"]][["version"]]
[01:28:10.342]                         if (is.null(version)) 
[01:28:10.342]                           version <- utils::packageVersion("future")
[01:28:10.342]                       }
[01:28:10.342]                       else {
[01:28:10.342]                         version <- NULL
[01:28:10.342]                       }
[01:28:10.342]                       if (!has_future || version < "1.8.0") {
[01:28:10.342]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.342]                           "", base::R.version$version.string), 
[01:28:10.342]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:10.342]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.342]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.342]                             "release", "version")], collapse = " "), 
[01:28:10.342]                           hostname = base::Sys.info()[["nodename"]])
[01:28:10.342]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.342]                           info)
[01:28:10.342]                         info <- base::paste(info, collapse = "; ")
[01:28:10.342]                         if (!has_future) {
[01:28:10.342]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.342]                             info)
[01:28:10.342]                         }
[01:28:10.342]                         else {
[01:28:10.342]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.342]                             info, version)
[01:28:10.342]                         }
[01:28:10.342]                         base::stop(msg)
[01:28:10.342]                       }
[01:28:10.342]                     })
[01:28:10.342]                   }
[01:28:10.342]                   options(future.plan = NULL)
[01:28:10.342]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.342]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.342]                 }
[01:28:10.342]                 ...future.workdir <- getwd()
[01:28:10.342]             }
[01:28:10.342]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.342]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.342]         }
[01:28:10.342]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.342]             future.globals.maxSize = NULL, future.globals.method = "conservative", 
[01:28:10.342]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.342]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.342]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.342]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.342]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.342]             base::names(...future.oldOptions))
[01:28:10.342]     }
[01:28:10.342]     if (FALSE) {
[01:28:10.342]     }
[01:28:10.342]     else {
[01:28:10.342]         if (TRUE) {
[01:28:10.342]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.342]                 open = "w")
[01:28:10.342]         }
[01:28:10.342]         else {
[01:28:10.342]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.342]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.342]         }
[01:28:10.342]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.342]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.342]             base::sink(type = "output", split = FALSE)
[01:28:10.342]             base::close(...future.stdout)
[01:28:10.342]         }, add = TRUE)
[01:28:10.342]     }
[01:28:10.342]     ...future.frame <- base::sys.nframe()
[01:28:10.342]     ...future.conditions <- base::list()
[01:28:10.342]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.342]     if (FALSE) {
[01:28:10.342]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.342]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.342]     }
[01:28:10.342]     ...future.result <- base::tryCatch({
[01:28:10.342]         base::withCallingHandlers({
[01:28:10.342]             ...future.value <- base::withVisible(base::local({
[01:28:10.342]                 pkg
[01:28:10.342]             }))
[01:28:10.342]             future::FutureResult(value = ...future.value$value, 
[01:28:10.342]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.342]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.342]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.342]                     ...future.globalenv.names))
[01:28:10.342]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.342]         }, condition = base::local({
[01:28:10.342]             c <- base::c
[01:28:10.342]             inherits <- base::inherits
[01:28:10.342]             invokeRestart <- base::invokeRestart
[01:28:10.342]             length <- base::length
[01:28:10.342]             list <- base::list
[01:28:10.342]             seq.int <- base::seq.int
[01:28:10.342]             signalCondition <- base::signalCondition
[01:28:10.342]             sys.calls <- base::sys.calls
[01:28:10.342]             `[[` <- base::`[[`
[01:28:10.342]             `+` <- base::`+`
[01:28:10.342]             `<<-` <- base::`<<-`
[01:28:10.342]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.342]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.342]                   3L)]
[01:28:10.342]             }
[01:28:10.342]             function(cond) {
[01:28:10.342]                 is_error <- inherits(cond, "error")
[01:28:10.342]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.342]                   NULL)
[01:28:10.342]                 if (is_error) {
[01:28:10.342]                   sessionInformation <- function() {
[01:28:10.342]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.342]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.342]                       search = base::search(), system = base::Sys.info())
[01:28:10.342]                   }
[01:28:10.342]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.342]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.342]                     cond$call), session = sessionInformation(), 
[01:28:10.342]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.342]                   signalCondition(cond)
[01:28:10.342]                 }
[01:28:10.342]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.342]                 "immediateCondition"))) {
[01:28:10.342]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.342]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.342]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.342]                   if (TRUE && !signal) {
[01:28:10.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.342]                     {
[01:28:10.342]                       inherits <- base::inherits
[01:28:10.342]                       invokeRestart <- base::invokeRestart
[01:28:10.342]                       is.null <- base::is.null
[01:28:10.342]                       muffled <- FALSE
[01:28:10.342]                       if (inherits(cond, "message")) {
[01:28:10.342]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.342]                         if (muffled) 
[01:28:10.342]                           invokeRestart("muffleMessage")
[01:28:10.342]                       }
[01:28:10.342]                       else if (inherits(cond, "warning")) {
[01:28:10.342]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.342]                         if (muffled) 
[01:28:10.342]                           invokeRestart("muffleWarning")
[01:28:10.342]                       }
[01:28:10.342]                       else if (inherits(cond, "condition")) {
[01:28:10.342]                         if (!is.null(pattern)) {
[01:28:10.342]                           computeRestarts <- base::computeRestarts
[01:28:10.342]                           grepl <- base::grepl
[01:28:10.342]                           restarts <- computeRestarts(cond)
[01:28:10.342]                           for (restart in restarts) {
[01:28:10.342]                             name <- restart$name
[01:28:10.342]                             if (is.null(name)) 
[01:28:10.342]                               next
[01:28:10.342]                             if (!grepl(pattern, name)) 
[01:28:10.342]                               next
[01:28:10.342]                             invokeRestart(restart)
[01:28:10.342]                             muffled <- TRUE
[01:28:10.342]                             break
[01:28:10.342]                           }
[01:28:10.342]                         }
[01:28:10.342]                       }
[01:28:10.342]                       invisible(muffled)
[01:28:10.342]                     }
[01:28:10.342]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.342]                   }
[01:28:10.342]                 }
[01:28:10.342]                 else {
[01:28:10.342]                   if (TRUE) {
[01:28:10.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.342]                     {
[01:28:10.342]                       inherits <- base::inherits
[01:28:10.342]                       invokeRestart <- base::invokeRestart
[01:28:10.342]                       is.null <- base::is.null
[01:28:10.342]                       muffled <- FALSE
[01:28:10.342]                       if (inherits(cond, "message")) {
[01:28:10.342]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.342]                         if (muffled) 
[01:28:10.342]                           invokeRestart("muffleMessage")
[01:28:10.342]                       }
[01:28:10.342]                       else if (inherits(cond, "warning")) {
[01:28:10.342]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.342]                         if (muffled) 
[01:28:10.342]                           invokeRestart("muffleWarning")
[01:28:10.342]                       }
[01:28:10.342]                       else if (inherits(cond, "condition")) {
[01:28:10.342]                         if (!is.null(pattern)) {
[01:28:10.342]                           computeRestarts <- base::computeRestarts
[01:28:10.342]                           grepl <- base::grepl
[01:28:10.342]                           restarts <- computeRestarts(cond)
[01:28:10.342]                           for (restart in restarts) {
[01:28:10.342]                             name <- restart$name
[01:28:10.342]                             if (is.null(name)) 
[01:28:10.342]                               next
[01:28:10.342]                             if (!grepl(pattern, name)) 
[01:28:10.342]                               next
[01:28:10.342]                             invokeRestart(restart)
[01:28:10.342]                             muffled <- TRUE
[01:28:10.342]                             break
[01:28:10.342]                           }
[01:28:10.342]                         }
[01:28:10.342]                       }
[01:28:10.342]                       invisible(muffled)
[01:28:10.342]                     }
[01:28:10.342]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.342]                   }
[01:28:10.342]                 }
[01:28:10.342]             }
[01:28:10.342]         }))
[01:28:10.342]     }, error = function(ex) {
[01:28:10.342]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.342]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.342]                 ...future.rng), started = ...future.startTime, 
[01:28:10.342]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.342]             version = "1.8"), class = "FutureResult")
[01:28:10.342]     }, finally = {
[01:28:10.342]         if (!identical(...future.workdir, getwd())) 
[01:28:10.342]             setwd(...future.workdir)
[01:28:10.342]         {
[01:28:10.342]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.342]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.342]             }
[01:28:10.342]             base::options(...future.oldOptions)
[01:28:10.342]             if (.Platform$OS.type == "windows") {
[01:28:10.342]                 old_names <- names(...future.oldEnvVars)
[01:28:10.342]                 envs <- base::Sys.getenv()
[01:28:10.342]                 names <- names(envs)
[01:28:10.342]                 common <- intersect(names, old_names)
[01:28:10.342]                 added <- setdiff(names, old_names)
[01:28:10.342]                 removed <- setdiff(old_names, names)
[01:28:10.342]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.342]                   envs[common]]
[01:28:10.342]                 NAMES <- toupper(changed)
[01:28:10.342]                 args <- list()
[01:28:10.342]                 for (kk in seq_along(NAMES)) {
[01:28:10.342]                   name <- changed[[kk]]
[01:28:10.342]                   NAME <- NAMES[[kk]]
[01:28:10.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.342]                     next
[01:28:10.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.342]                 }
[01:28:10.342]                 NAMES <- toupper(added)
[01:28:10.342]                 for (kk in seq_along(NAMES)) {
[01:28:10.342]                   name <- added[[kk]]
[01:28:10.342]                   NAME <- NAMES[[kk]]
[01:28:10.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.342]                     next
[01:28:10.342]                   args[[name]] <- ""
[01:28:10.342]                 }
[01:28:10.342]                 NAMES <- toupper(removed)
[01:28:10.342]                 for (kk in seq_along(NAMES)) {
[01:28:10.342]                   name <- removed[[kk]]
[01:28:10.342]                   NAME <- NAMES[[kk]]
[01:28:10.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.342]                     next
[01:28:10.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.342]                 }
[01:28:10.342]                 if (length(args) > 0) 
[01:28:10.342]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.342]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.342]             }
[01:28:10.342]             else {
[01:28:10.342]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.342]             }
[01:28:10.342]             {
[01:28:10.342]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.342]                   0L) {
[01:28:10.342]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.342]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.342]                   base::options(opts)
[01:28:10.342]                 }
[01:28:10.342]                 {
[01:28:10.342]                   {
[01:28:10.342]                     NULL
[01:28:10.342]                     RNGkind("Mersenne-Twister")
[01:28:10.342]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:10.342]                       inherits = FALSE)
[01:28:10.342]                   }
[01:28:10.342]                   options(future.plan = NULL)
[01:28:10.342]                   if (is.na(NA_character_)) 
[01:28:10.342]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.342]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.342]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.342]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.342]                     envir = parent.frame()) 
[01:28:10.342]                   {
[01:28:10.342]                     if (is.function(workers)) 
[01:28:10.342]                       workers <- workers()
[01:28:10.342]                     workers <- structure(as.integer(workers), 
[01:28:10.342]                       class = class(workers))
[01:28:10.342]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.342]                       workers >= 1)
[01:28:10.342]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.342]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.342]                     }
[01:28:10.342]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.342]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.342]                       envir = envir)
[01:28:10.342]                     if (!future$lazy) 
[01:28:10.342]                       future <- run(future)
[01:28:10.342]                     invisible(future)
[01:28:10.342]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.342]                 }
[01:28:10.342]             }
[01:28:10.342]         }
[01:28:10.342]     })
[01:28:10.342]     if (TRUE) {
[01:28:10.342]         base::sink(type = "output", split = FALSE)
[01:28:10.342]         if (TRUE) {
[01:28:10.342]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.342]         }
[01:28:10.342]         else {
[01:28:10.342]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.342]         }
[01:28:10.342]         base::close(...future.stdout)
[01:28:10.342]         ...future.stdout <- NULL
[01:28:10.342]     }
[01:28:10.342]     ...future.result$conditions <- ...future.conditions
[01:28:10.342]     ...future.result$finished <- base::Sys.time()
[01:28:10.342]     ...future.result
[01:28:10.342] }
[01:28:10.346] assign_globals() ...
[01:28:10.346] List of 1
[01:28:10.346]  $ pkg: chr "foo"
[01:28:10.346]  - attr(*, "where")=List of 1
[01:28:10.346]   ..$ pkg:<environment: R_EmptyEnv> 
[01:28:10.346]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:10.346]  - attr(*, "resolved")= logi TRUE
[01:28:10.346]  - attr(*, "total_size")= num 112
[01:28:10.349] - copied 'pkg' to environment
[01:28:10.349] assign_globals() ... done
[01:28:10.350] plan(): Setting new future strategy stack:
[01:28:10.350] List of future strategies:
[01:28:10.350] 1. sequential:
[01:28:10.350]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:10.350]    - tweaked: FALSE
[01:28:10.350]    - call: NULL
[01:28:10.350] plan(): nbrOfWorkers() = 1
[01:28:10.352] plan(): Setting new future strategy stack:
[01:28:10.352] List of future strategies:
[01:28:10.352] 1. multisession:
[01:28:10.352]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:10.352]    - tweaked: FALSE
[01:28:10.352]    - call: plan(strategy)
[01:28:10.355] plan(): nbrOfWorkers() = 2
[01:28:10.355] SequentialFuture started (and completed)
value(f) = 'foo'
Method for identifying globals: 'conservative' ... DONE
Method for identifying globals: 'ordered' ...
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.356] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.356] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.359] - globals found: [4] '{', '<-', 'a', '*'
[01:28:10.359] Searching for globals ... DONE
[01:28:10.359] Resolving globals: TRUE
[01:28:10.359] Resolving any globals that are futures ...
[01:28:10.359] - globals: [4] '{', '<-', 'a', '*'
[01:28:10.360] Resolving any globals that are futures ... DONE
[01:28:10.360] Resolving futures part of globals (recursively) ...
[01:28:10.361] resolve() on list ...
[01:28:10.361]  recursive: 99
[01:28:10.361]  length: 1
[01:28:10.361]  elements: 'a'
[01:28:10.361]  length: 0 (resolved future 1)
[01:28:10.361] resolve() on list ... DONE
[01:28:10.362] - globals: [1] 'a'
[01:28:10.362] Resolving futures part of globals (recursively) ... DONE
[01:28:10.362] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:10.362] The total size of the 1 globals exported for future expression ('{; b <- a; a <- 2; a * b; }') 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:10.363] - globals: [1] 'a'
[01:28:10.363] 
[01:28:10.363] getGlobalsAndPackages() ... DONE
[01:28:10.363] run() for 'Future' ...
[01:28:10.364] - state: 'created'
[01:28:10.364] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.378] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.378] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.379]   - Field: 'node'
[01:28:10.379]   - Field: 'label'
[01:28:10.379]   - Field: 'local'
[01:28:10.379]   - Field: 'owner'
[01:28:10.379]   - Field: 'envir'
[01:28:10.379]   - Field: 'workers'
[01:28:10.380]   - Field: 'packages'
[01:28:10.380]   - Field: 'gc'
[01:28:10.380]   - Field: 'conditions'
[01:28:10.380]   - Field: 'persistent'
[01:28:10.380]   - Field: 'expr'
[01:28:10.381]   - Field: 'uuid'
[01:28:10.381]   - Field: 'seed'
[01:28:10.381]   - Field: 'version'
[01:28:10.381]   - Field: 'result'
[01:28:10.381]   - Field: 'asynchronous'
[01:28:10.381]   - Field: 'calls'
[01:28:10.382]   - Field: 'globals'
[01:28:10.382]   - Field: 'stdout'
[01:28:10.382]   - Field: 'earlySignal'
[01:28:10.382]   - Field: 'lazy'
[01:28:10.382]   - Field: 'state'
[01:28:10.382] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.383] - Launch lazy future ...
[01:28:10.383] Packages needed by the future expression (n = 0): <none>
[01:28:10.383] Packages needed by future strategies (n = 0): <none>
[01:28:10.384] {
[01:28:10.384]     {
[01:28:10.384]         {
[01:28:10.384]             ...future.startTime <- base::Sys.time()
[01:28:10.384]             {
[01:28:10.384]                 {
[01:28:10.384]                   {
[01:28:10.384]                     {
[01:28:10.384]                       base::local({
[01:28:10.384]                         has_future <- base::requireNamespace("future", 
[01:28:10.384]                           quietly = TRUE)
[01:28:10.384]                         if (has_future) {
[01:28:10.384]                           ns <- base::getNamespace("future")
[01:28:10.384]                           version <- ns[[".package"]][["version"]]
[01:28:10.384]                           if (is.null(version)) 
[01:28:10.384]                             version <- utils::packageVersion("future")
[01:28:10.384]                         }
[01:28:10.384]                         else {
[01:28:10.384]                           version <- NULL
[01:28:10.384]                         }
[01:28:10.384]                         if (!has_future || version < "1.8.0") {
[01:28:10.384]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.384]                             "", base::R.version$version.string), 
[01:28:10.384]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.384]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.384]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.384]                               "release", "version")], collapse = " "), 
[01:28:10.384]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.384]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.384]                             info)
[01:28:10.384]                           info <- base::paste(info, collapse = "; ")
[01:28:10.384]                           if (!has_future) {
[01:28:10.384]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.384]                               info)
[01:28:10.384]                           }
[01:28:10.384]                           else {
[01:28:10.384]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.384]                               info, version)
[01:28:10.384]                           }
[01:28:10.384]                           base::stop(msg)
[01:28:10.384]                         }
[01:28:10.384]                       })
[01:28:10.384]                     }
[01:28:10.384]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.384]                     base::options(mc.cores = 1L)
[01:28:10.384]                   }
[01:28:10.384]                   options(future.plan = NULL)
[01:28:10.384]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.384]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.384]                 }
[01:28:10.384]                 ...future.workdir <- getwd()
[01:28:10.384]             }
[01:28:10.384]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.384]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.384]         }
[01:28:10.384]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.384]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.384]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.384]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.384]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.384]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.384]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.384]             base::names(...future.oldOptions))
[01:28:10.384]     }
[01:28:10.384]     if (FALSE) {
[01:28:10.384]     }
[01:28:10.384]     else {
[01:28:10.384]         if (TRUE) {
[01:28:10.384]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.384]                 open = "w")
[01:28:10.384]         }
[01:28:10.384]         else {
[01:28:10.384]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.384]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.384]         }
[01:28:10.384]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.384]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.384]             base::sink(type = "output", split = FALSE)
[01:28:10.384]             base::close(...future.stdout)
[01:28:10.384]         }, add = TRUE)
[01:28:10.384]     }
[01:28:10.384]     ...future.frame <- base::sys.nframe()
[01:28:10.384]     ...future.conditions <- base::list()
[01:28:10.384]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.384]     if (FALSE) {
[01:28:10.384]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.384]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.384]     }
[01:28:10.384]     ...future.result <- base::tryCatch({
[01:28:10.384]         base::withCallingHandlers({
[01:28:10.384]             ...future.value <- base::withVisible(base::local({
[01:28:10.384]                 ...future.makeSendCondition <- base::local({
[01:28:10.384]                   sendCondition <- NULL
[01:28:10.384]                   function(frame = 1L) {
[01:28:10.384]                     if (is.function(sendCondition)) 
[01:28:10.384]                       return(sendCondition)
[01:28:10.384]                     ns <- getNamespace("parallel")
[01:28:10.384]                     if (exists("sendData", mode = "function", 
[01:28:10.384]                       envir = ns)) {
[01:28:10.384]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.384]                         envir = ns)
[01:28:10.384]                       envir <- sys.frame(frame)
[01:28:10.384]                       master <- NULL
[01:28:10.384]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.384]                         !identical(envir, emptyenv())) {
[01:28:10.384]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.384]                           inherits = FALSE)) {
[01:28:10.384]                           master <- get("master", mode = "list", 
[01:28:10.384]                             envir = envir, inherits = FALSE)
[01:28:10.384]                           if (inherits(master, c("SOCKnode", 
[01:28:10.384]                             "SOCK0node"))) {
[01:28:10.384]                             sendCondition <<- function(cond) {
[01:28:10.384]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.384]                                 success = TRUE)
[01:28:10.384]                               parallel_sendData(master, data)
[01:28:10.384]                             }
[01:28:10.384]                             return(sendCondition)
[01:28:10.384]                           }
[01:28:10.384]                         }
[01:28:10.384]                         frame <- frame + 1L
[01:28:10.384]                         envir <- sys.frame(frame)
[01:28:10.384]                       }
[01:28:10.384]                     }
[01:28:10.384]                     sendCondition <<- function(cond) NULL
[01:28:10.384]                   }
[01:28:10.384]                 })
[01:28:10.384]                 withCallingHandlers({
[01:28:10.384]                   {
[01:28:10.384]                     b <- a
[01:28:10.384]                     a <- 2
[01:28:10.384]                     a * b
[01:28:10.384]                   }
[01:28:10.384]                 }, immediateCondition = function(cond) {
[01:28:10.384]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.384]                   sendCondition(cond)
[01:28:10.384]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.384]                   {
[01:28:10.384]                     inherits <- base::inherits
[01:28:10.384]                     invokeRestart <- base::invokeRestart
[01:28:10.384]                     is.null <- base::is.null
[01:28:10.384]                     muffled <- FALSE
[01:28:10.384]                     if (inherits(cond, "message")) {
[01:28:10.384]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.384]                       if (muffled) 
[01:28:10.384]                         invokeRestart("muffleMessage")
[01:28:10.384]                     }
[01:28:10.384]                     else if (inherits(cond, "warning")) {
[01:28:10.384]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.384]                       if (muffled) 
[01:28:10.384]                         invokeRestart("muffleWarning")
[01:28:10.384]                     }
[01:28:10.384]                     else if (inherits(cond, "condition")) {
[01:28:10.384]                       if (!is.null(pattern)) {
[01:28:10.384]                         computeRestarts <- base::computeRestarts
[01:28:10.384]                         grepl <- base::grepl
[01:28:10.384]                         restarts <- computeRestarts(cond)
[01:28:10.384]                         for (restart in restarts) {
[01:28:10.384]                           name <- restart$name
[01:28:10.384]                           if (is.null(name)) 
[01:28:10.384]                             next
[01:28:10.384]                           if (!grepl(pattern, name)) 
[01:28:10.384]                             next
[01:28:10.384]                           invokeRestart(restart)
[01:28:10.384]                           muffled <- TRUE
[01:28:10.384]                           break
[01:28:10.384]                         }
[01:28:10.384]                       }
[01:28:10.384]                     }
[01:28:10.384]                     invisible(muffled)
[01:28:10.384]                   }
[01:28:10.384]                   muffleCondition(cond)
[01:28:10.384]                 })
[01:28:10.384]             }))
[01:28:10.384]             future::FutureResult(value = ...future.value$value, 
[01:28:10.384]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.384]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.384]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.384]                     ...future.globalenv.names))
[01:28:10.384]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.384]         }, condition = base::local({
[01:28:10.384]             c <- base::c
[01:28:10.384]             inherits <- base::inherits
[01:28:10.384]             invokeRestart <- base::invokeRestart
[01:28:10.384]             length <- base::length
[01:28:10.384]             list <- base::list
[01:28:10.384]             seq.int <- base::seq.int
[01:28:10.384]             signalCondition <- base::signalCondition
[01:28:10.384]             sys.calls <- base::sys.calls
[01:28:10.384]             `[[` <- base::`[[`
[01:28:10.384]             `+` <- base::`+`
[01:28:10.384]             `<<-` <- base::`<<-`
[01:28:10.384]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.384]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.384]                   3L)]
[01:28:10.384]             }
[01:28:10.384]             function(cond) {
[01:28:10.384]                 is_error <- inherits(cond, "error")
[01:28:10.384]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.384]                   NULL)
[01:28:10.384]                 if (is_error) {
[01:28:10.384]                   sessionInformation <- function() {
[01:28:10.384]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.384]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.384]                       search = base::search(), system = base::Sys.info())
[01:28:10.384]                   }
[01:28:10.384]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.384]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.384]                     cond$call), session = sessionInformation(), 
[01:28:10.384]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.384]                   signalCondition(cond)
[01:28:10.384]                 }
[01:28:10.384]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.384]                 "immediateCondition"))) {
[01:28:10.384]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.384]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.384]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.384]                   if (TRUE && !signal) {
[01:28:10.384]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.384]                     {
[01:28:10.384]                       inherits <- base::inherits
[01:28:10.384]                       invokeRestart <- base::invokeRestart
[01:28:10.384]                       is.null <- base::is.null
[01:28:10.384]                       muffled <- FALSE
[01:28:10.384]                       if (inherits(cond, "message")) {
[01:28:10.384]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.384]                         if (muffled) 
[01:28:10.384]                           invokeRestart("muffleMessage")
[01:28:10.384]                       }
[01:28:10.384]                       else if (inherits(cond, "warning")) {
[01:28:10.384]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.384]                         if (muffled) 
[01:28:10.384]                           invokeRestart("muffleWarning")
[01:28:10.384]                       }
[01:28:10.384]                       else if (inherits(cond, "condition")) {
[01:28:10.384]                         if (!is.null(pattern)) {
[01:28:10.384]                           computeRestarts <- base::computeRestarts
[01:28:10.384]                           grepl <- base::grepl
[01:28:10.384]                           restarts <- computeRestarts(cond)
[01:28:10.384]                           for (restart in restarts) {
[01:28:10.384]                             name <- restart$name
[01:28:10.384]                             if (is.null(name)) 
[01:28:10.384]                               next
[01:28:10.384]                             if (!grepl(pattern, name)) 
[01:28:10.384]                               next
[01:28:10.384]                             invokeRestart(restart)
[01:28:10.384]                             muffled <- TRUE
[01:28:10.384]                             break
[01:28:10.384]                           }
[01:28:10.384]                         }
[01:28:10.384]                       }
[01:28:10.384]                       invisible(muffled)
[01:28:10.384]                     }
[01:28:10.384]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.384]                   }
[01:28:10.384]                 }
[01:28:10.384]                 else {
[01:28:10.384]                   if (TRUE) {
[01:28:10.384]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.384]                     {
[01:28:10.384]                       inherits <- base::inherits
[01:28:10.384]                       invokeRestart <- base::invokeRestart
[01:28:10.384]                       is.null <- base::is.null
[01:28:10.384]                       muffled <- FALSE
[01:28:10.384]                       if (inherits(cond, "message")) {
[01:28:10.384]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.384]                         if (muffled) 
[01:28:10.384]                           invokeRestart("muffleMessage")
[01:28:10.384]                       }
[01:28:10.384]                       else if (inherits(cond, "warning")) {
[01:28:10.384]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.384]                         if (muffled) 
[01:28:10.384]                           invokeRestart("muffleWarning")
[01:28:10.384]                       }
[01:28:10.384]                       else if (inherits(cond, "condition")) {
[01:28:10.384]                         if (!is.null(pattern)) {
[01:28:10.384]                           computeRestarts <- base::computeRestarts
[01:28:10.384]                           grepl <- base::grepl
[01:28:10.384]                           restarts <- computeRestarts(cond)
[01:28:10.384]                           for (restart in restarts) {
[01:28:10.384]                             name <- restart$name
[01:28:10.384]                             if (is.null(name)) 
[01:28:10.384]                               next
[01:28:10.384]                             if (!grepl(pattern, name)) 
[01:28:10.384]                               next
[01:28:10.384]                             invokeRestart(restart)
[01:28:10.384]                             muffled <- TRUE
[01:28:10.384]                             break
[01:28:10.384]                           }
[01:28:10.384]                         }
[01:28:10.384]                       }
[01:28:10.384]                       invisible(muffled)
[01:28:10.384]                     }
[01:28:10.384]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.384]                   }
[01:28:10.384]                 }
[01:28:10.384]             }
[01:28:10.384]         }))
[01:28:10.384]     }, error = function(ex) {
[01:28:10.384]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.384]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.384]                 ...future.rng), started = ...future.startTime, 
[01:28:10.384]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.384]             version = "1.8"), class = "FutureResult")
[01:28:10.384]     }, finally = {
[01:28:10.384]         if (!identical(...future.workdir, getwd())) 
[01:28:10.384]             setwd(...future.workdir)
[01:28:10.384]         {
[01:28:10.384]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.384]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.384]             }
[01:28:10.384]             base::options(...future.oldOptions)
[01:28:10.384]             if (.Platform$OS.type == "windows") {
[01:28:10.384]                 old_names <- names(...future.oldEnvVars)
[01:28:10.384]                 envs <- base::Sys.getenv()
[01:28:10.384]                 names <- names(envs)
[01:28:10.384]                 common <- intersect(names, old_names)
[01:28:10.384]                 added <- setdiff(names, old_names)
[01:28:10.384]                 removed <- setdiff(old_names, names)
[01:28:10.384]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.384]                   envs[common]]
[01:28:10.384]                 NAMES <- toupper(changed)
[01:28:10.384]                 args <- list()
[01:28:10.384]                 for (kk in seq_along(NAMES)) {
[01:28:10.384]                   name <- changed[[kk]]
[01:28:10.384]                   NAME <- NAMES[[kk]]
[01:28:10.384]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.384]                     next
[01:28:10.384]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.384]                 }
[01:28:10.384]                 NAMES <- toupper(added)
[01:28:10.384]                 for (kk in seq_along(NAMES)) {
[01:28:10.384]                   name <- added[[kk]]
[01:28:10.384]                   NAME <- NAMES[[kk]]
[01:28:10.384]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.384]                     next
[01:28:10.384]                   args[[name]] <- ""
[01:28:10.384]                 }
[01:28:10.384]                 NAMES <- toupper(removed)
[01:28:10.384]                 for (kk in seq_along(NAMES)) {
[01:28:10.384]                   name <- removed[[kk]]
[01:28:10.384]                   NAME <- NAMES[[kk]]
[01:28:10.384]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.384]                     next
[01:28:10.384]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.384]                 }
[01:28:10.384]                 if (length(args) > 0) 
[01:28:10.384]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.384]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.384]             }
[01:28:10.384]             else {
[01:28:10.384]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.384]             }
[01:28:10.384]             {
[01:28:10.384]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.384]                   0L) {
[01:28:10.384]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.384]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.384]                   base::options(opts)
[01:28:10.384]                 }
[01:28:10.384]                 {
[01:28:10.384]                   {
[01:28:10.384]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.384]                     NULL
[01:28:10.384]                   }
[01:28:10.384]                   options(future.plan = NULL)
[01:28:10.384]                   if (is.na(NA_character_)) 
[01:28:10.384]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.384]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.384]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.384]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.384]                     envir = parent.frame()) 
[01:28:10.384]                   {
[01:28:10.384]                     if (is.function(workers)) 
[01:28:10.384]                       workers <- workers()
[01:28:10.384]                     workers <- structure(as.integer(workers), 
[01:28:10.384]                       class = class(workers))
[01:28:10.384]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.384]                       workers >= 1)
[01:28:10.384]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.384]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.384]                     }
[01:28:10.384]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.384]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.384]                       envir = envir)
[01:28:10.384]                     if (!future$lazy) 
[01:28:10.384]                       future <- run(future)
[01:28:10.384]                     invisible(future)
[01:28:10.384]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.384]                 }
[01:28:10.384]             }
[01:28:10.384]         }
[01:28:10.384]     })
[01:28:10.384]     if (TRUE) {
[01:28:10.384]         base::sink(type = "output", split = FALSE)
[01:28:10.384]         if (TRUE) {
[01:28:10.384]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.384]         }
[01:28:10.384]         else {
[01:28:10.384]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.384]         }
[01:28:10.384]         base::close(...future.stdout)
[01:28:10.384]         ...future.stdout <- NULL
[01:28:10.384]     }
[01:28:10.384]     ...future.result$conditions <- ...future.conditions
[01:28:10.384]     ...future.result$finished <- base::Sys.time()
[01:28:10.384]     ...future.result
[01:28:10.384] }
[01:28:10.389] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[01:28:10.390] Exporting 'a' (56 bytes) to cluster node #2 ...
[01:28:10.390] Exporting 'a' (56 bytes) to cluster node #2 ... DONE
[01:28:10.390] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[01:28:10.391] MultisessionFuture started
[01:28:10.391] - Launch lazy future ... done
[01:28:10.391] run() for 'MultisessionFuture' ... done
[01:28:10.392] result() for ClusterFuture ...
[01:28:10.392] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.392] - Validating connection of MultisessionFuture
[01:28:10.410] - received message: FutureResult
[01:28:10.410] - Received FutureResult
[01:28:10.410] - Erased future from FutureRegistry
[01:28:10.410] result() for ClusterFuture ...
[01:28:10.411] - result already collected: FutureResult
[01:28:10.411] result() for ClusterFuture ... done
[01:28:10.411] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.411] result() for ClusterFuture ... done
[01:28:10.411] result() for ClusterFuture ...
[01:28:10.411] - result already collected: FutureResult
[01:28:10.412] result() for ClusterFuture ... done
y = 6
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.412] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.413] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.415] - globals found: [4] '{', '<-', 'a', '*'
[01:28:10.415] Searching for globals ... DONE
[01:28:10.415] Resolving globals: TRUE
[01:28:10.416] Resolving any globals that are futures ...
[01:28:10.416] - globals: [4] '{', '<-', 'a', '*'
[01:28:10.416] Resolving any globals that are futures ... DONE
[01:28:10.416] Resolving futures part of globals (recursively) ...
[01:28:10.417] resolve() on list ...
[01:28:10.417]  recursive: 99
[01:28:10.417]  length: 1
[01:28:10.417]  elements: 'a'
[01:28:10.417]  length: 0 (resolved future 1)
[01:28:10.418] resolve() on list ... DONE
[01:28:10.418] - globals: [1] 'a'
[01:28:10.418] Resolving futures part of globals (recursively) ... DONE
[01:28:10.418] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:10.419] The total size of the 1 globals exported for future expression ('{; b <- a; a <- 2; a * b; }') 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:10.419] - globals: [1] 'a'
[01:28:10.419] 
[01:28:10.419] getGlobalsAndPackages() ... DONE
[01:28:10.420] run() for 'Future' ...
[01:28:10.420] - state: 'created'
[01:28:10.420] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.435] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.435] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.435]   - Field: 'node'
[01:28:10.435]   - Field: 'label'
[01:28:10.435]   - Field: 'local'
[01:28:10.436]   - Field: 'owner'
[01:28:10.436]   - Field: 'envir'
[01:28:10.436]   - Field: 'workers'
[01:28:10.436]   - Field: 'packages'
[01:28:10.436]   - Field: 'gc'
[01:28:10.437]   - Field: 'conditions'
[01:28:10.437]   - Field: 'persistent'
[01:28:10.437]   - Field: 'expr'
[01:28:10.437]   - Field: 'uuid'
[01:28:10.437]   - Field: 'seed'
[01:28:10.437]   - Field: 'version'
[01:28:10.438]   - Field: 'result'
[01:28:10.438]   - Field: 'asynchronous'
[01:28:10.438]   - Field: 'calls'
[01:28:10.438]   - Field: 'globals'
[01:28:10.438]   - Field: 'stdout'
[01:28:10.439]   - Field: 'earlySignal'
[01:28:10.439]   - Field: 'lazy'
[01:28:10.439]   - Field: 'state'
[01:28:10.439] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.439] - Launch lazy future ...
[01:28:10.440] Packages needed by the future expression (n = 0): <none>
[01:28:10.440] Packages needed by future strategies (n = 0): <none>
[01:28:10.440] {
[01:28:10.440]     {
[01:28:10.440]         {
[01:28:10.440]             ...future.startTime <- base::Sys.time()
[01:28:10.440]             {
[01:28:10.440]                 {
[01:28:10.440]                   {
[01:28:10.440]                     {
[01:28:10.440]                       base::local({
[01:28:10.440]                         has_future <- base::requireNamespace("future", 
[01:28:10.440]                           quietly = TRUE)
[01:28:10.440]                         if (has_future) {
[01:28:10.440]                           ns <- base::getNamespace("future")
[01:28:10.440]                           version <- ns[[".package"]][["version"]]
[01:28:10.440]                           if (is.null(version)) 
[01:28:10.440]                             version <- utils::packageVersion("future")
[01:28:10.440]                         }
[01:28:10.440]                         else {
[01:28:10.440]                           version <- NULL
[01:28:10.440]                         }
[01:28:10.440]                         if (!has_future || version < "1.8.0") {
[01:28:10.440]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.440]                             "", base::R.version$version.string), 
[01:28:10.440]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.440]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.440]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.440]                               "release", "version")], collapse = " "), 
[01:28:10.440]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.440]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.440]                             info)
[01:28:10.440]                           info <- base::paste(info, collapse = "; ")
[01:28:10.440]                           if (!has_future) {
[01:28:10.440]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.440]                               info)
[01:28:10.440]                           }
[01:28:10.440]                           else {
[01:28:10.440]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.440]                               info, version)
[01:28:10.440]                           }
[01:28:10.440]                           base::stop(msg)
[01:28:10.440]                         }
[01:28:10.440]                       })
[01:28:10.440]                     }
[01:28:10.440]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.440]                     base::options(mc.cores = 1L)
[01:28:10.440]                   }
[01:28:10.440]                   options(future.plan = NULL)
[01:28:10.440]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.440]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.440]                 }
[01:28:10.440]                 ...future.workdir <- getwd()
[01:28:10.440]             }
[01:28:10.440]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.440]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.440]         }
[01:28:10.440]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.440]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.440]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.440]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.440]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.440]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.440]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.440]             base::names(...future.oldOptions))
[01:28:10.440]     }
[01:28:10.440]     if (FALSE) {
[01:28:10.440]     }
[01:28:10.440]     else {
[01:28:10.440]         if (TRUE) {
[01:28:10.440]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.440]                 open = "w")
[01:28:10.440]         }
[01:28:10.440]         else {
[01:28:10.440]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.440]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.440]         }
[01:28:10.440]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.440]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.440]             base::sink(type = "output", split = FALSE)
[01:28:10.440]             base::close(...future.stdout)
[01:28:10.440]         }, add = TRUE)
[01:28:10.440]     }
[01:28:10.440]     ...future.frame <- base::sys.nframe()
[01:28:10.440]     ...future.conditions <- base::list()
[01:28:10.440]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.440]     if (FALSE) {
[01:28:10.440]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.440]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.440]     }
[01:28:10.440]     ...future.result <- base::tryCatch({
[01:28:10.440]         base::withCallingHandlers({
[01:28:10.440]             ...future.value <- base::withVisible(base::local({
[01:28:10.440]                 ...future.makeSendCondition <- base::local({
[01:28:10.440]                   sendCondition <- NULL
[01:28:10.440]                   function(frame = 1L) {
[01:28:10.440]                     if (is.function(sendCondition)) 
[01:28:10.440]                       return(sendCondition)
[01:28:10.440]                     ns <- getNamespace("parallel")
[01:28:10.440]                     if (exists("sendData", mode = "function", 
[01:28:10.440]                       envir = ns)) {
[01:28:10.440]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.440]                         envir = ns)
[01:28:10.440]                       envir <- sys.frame(frame)
[01:28:10.440]                       master <- NULL
[01:28:10.440]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.440]                         !identical(envir, emptyenv())) {
[01:28:10.440]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.440]                           inherits = FALSE)) {
[01:28:10.440]                           master <- get("master", mode = "list", 
[01:28:10.440]                             envir = envir, inherits = FALSE)
[01:28:10.440]                           if (inherits(master, c("SOCKnode", 
[01:28:10.440]                             "SOCK0node"))) {
[01:28:10.440]                             sendCondition <<- function(cond) {
[01:28:10.440]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.440]                                 success = TRUE)
[01:28:10.440]                               parallel_sendData(master, data)
[01:28:10.440]                             }
[01:28:10.440]                             return(sendCondition)
[01:28:10.440]                           }
[01:28:10.440]                         }
[01:28:10.440]                         frame <- frame + 1L
[01:28:10.440]                         envir <- sys.frame(frame)
[01:28:10.440]                       }
[01:28:10.440]                     }
[01:28:10.440]                     sendCondition <<- function(cond) NULL
[01:28:10.440]                   }
[01:28:10.440]                 })
[01:28:10.440]                 withCallingHandlers({
[01:28:10.440]                   {
[01:28:10.440]                     b <- a
[01:28:10.440]                     a <- 2
[01:28:10.440]                     a * b
[01:28:10.440]                   }
[01:28:10.440]                 }, immediateCondition = function(cond) {
[01:28:10.440]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.440]                   sendCondition(cond)
[01:28:10.440]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.440]                   {
[01:28:10.440]                     inherits <- base::inherits
[01:28:10.440]                     invokeRestart <- base::invokeRestart
[01:28:10.440]                     is.null <- base::is.null
[01:28:10.440]                     muffled <- FALSE
[01:28:10.440]                     if (inherits(cond, "message")) {
[01:28:10.440]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.440]                       if (muffled) 
[01:28:10.440]                         invokeRestart("muffleMessage")
[01:28:10.440]                     }
[01:28:10.440]                     else if (inherits(cond, "warning")) {
[01:28:10.440]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.440]                       if (muffled) 
[01:28:10.440]                         invokeRestart("muffleWarning")
[01:28:10.440]                     }
[01:28:10.440]                     else if (inherits(cond, "condition")) {
[01:28:10.440]                       if (!is.null(pattern)) {
[01:28:10.440]                         computeRestarts <- base::computeRestarts
[01:28:10.440]                         grepl <- base::grepl
[01:28:10.440]                         restarts <- computeRestarts(cond)
[01:28:10.440]                         for (restart in restarts) {
[01:28:10.440]                           name <- restart$name
[01:28:10.440]                           if (is.null(name)) 
[01:28:10.440]                             next
[01:28:10.440]                           if (!grepl(pattern, name)) 
[01:28:10.440]                             next
[01:28:10.440]                           invokeRestart(restart)
[01:28:10.440]                           muffled <- TRUE
[01:28:10.440]                           break
[01:28:10.440]                         }
[01:28:10.440]                       }
[01:28:10.440]                     }
[01:28:10.440]                     invisible(muffled)
[01:28:10.440]                   }
[01:28:10.440]                   muffleCondition(cond)
[01:28:10.440]                 })
[01:28:10.440]             }))
[01:28:10.440]             future::FutureResult(value = ...future.value$value, 
[01:28:10.440]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.440]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.440]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.440]                     ...future.globalenv.names))
[01:28:10.440]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.440]         }, condition = base::local({
[01:28:10.440]             c <- base::c
[01:28:10.440]             inherits <- base::inherits
[01:28:10.440]             invokeRestart <- base::invokeRestart
[01:28:10.440]             length <- base::length
[01:28:10.440]             list <- base::list
[01:28:10.440]             seq.int <- base::seq.int
[01:28:10.440]             signalCondition <- base::signalCondition
[01:28:10.440]             sys.calls <- base::sys.calls
[01:28:10.440]             `[[` <- base::`[[`
[01:28:10.440]             `+` <- base::`+`
[01:28:10.440]             `<<-` <- base::`<<-`
[01:28:10.440]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.440]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.440]                   3L)]
[01:28:10.440]             }
[01:28:10.440]             function(cond) {
[01:28:10.440]                 is_error <- inherits(cond, "error")
[01:28:10.440]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.440]                   NULL)
[01:28:10.440]                 if (is_error) {
[01:28:10.440]                   sessionInformation <- function() {
[01:28:10.440]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.440]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.440]                       search = base::search(), system = base::Sys.info())
[01:28:10.440]                   }
[01:28:10.440]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.440]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.440]                     cond$call), session = sessionInformation(), 
[01:28:10.440]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.440]                   signalCondition(cond)
[01:28:10.440]                 }
[01:28:10.440]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.440]                 "immediateCondition"))) {
[01:28:10.440]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.440]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.440]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.440]                   if (TRUE && !signal) {
[01:28:10.440]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.440]                     {
[01:28:10.440]                       inherits <- base::inherits
[01:28:10.440]                       invokeRestart <- base::invokeRestart
[01:28:10.440]                       is.null <- base::is.null
[01:28:10.440]                       muffled <- FALSE
[01:28:10.440]                       if (inherits(cond, "message")) {
[01:28:10.440]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.440]                         if (muffled) 
[01:28:10.440]                           invokeRestart("muffleMessage")
[01:28:10.440]                       }
[01:28:10.440]                       else if (inherits(cond, "warning")) {
[01:28:10.440]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.440]                         if (muffled) 
[01:28:10.440]                           invokeRestart("muffleWarning")
[01:28:10.440]                       }
[01:28:10.440]                       else if (inherits(cond, "condition")) {
[01:28:10.440]                         if (!is.null(pattern)) {
[01:28:10.440]                           computeRestarts <- base::computeRestarts
[01:28:10.440]                           grepl <- base::grepl
[01:28:10.440]                           restarts <- computeRestarts(cond)
[01:28:10.440]                           for (restart in restarts) {
[01:28:10.440]                             name <- restart$name
[01:28:10.440]                             if (is.null(name)) 
[01:28:10.440]                               next
[01:28:10.440]                             if (!grepl(pattern, name)) 
[01:28:10.440]                               next
[01:28:10.440]                             invokeRestart(restart)
[01:28:10.440]                             muffled <- TRUE
[01:28:10.440]                             break
[01:28:10.440]                           }
[01:28:10.440]                         }
[01:28:10.440]                       }
[01:28:10.440]                       invisible(muffled)
[01:28:10.440]                     }
[01:28:10.440]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.440]                   }
[01:28:10.440]                 }
[01:28:10.440]                 else {
[01:28:10.440]                   if (TRUE) {
[01:28:10.440]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.440]                     {
[01:28:10.440]                       inherits <- base::inherits
[01:28:10.440]                       invokeRestart <- base::invokeRestart
[01:28:10.440]                       is.null <- base::is.null
[01:28:10.440]                       muffled <- FALSE
[01:28:10.440]                       if (inherits(cond, "message")) {
[01:28:10.440]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.440]                         if (muffled) 
[01:28:10.440]                           invokeRestart("muffleMessage")
[01:28:10.440]                       }
[01:28:10.440]                       else if (inherits(cond, "warning")) {
[01:28:10.440]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.440]                         if (muffled) 
[01:28:10.440]                           invokeRestart("muffleWarning")
[01:28:10.440]                       }
[01:28:10.440]                       else if (inherits(cond, "condition")) {
[01:28:10.440]                         if (!is.null(pattern)) {
[01:28:10.440]                           computeRestarts <- base::computeRestarts
[01:28:10.440]                           grepl <- base::grepl
[01:28:10.440]                           restarts <- computeRestarts(cond)
[01:28:10.440]                           for (restart in restarts) {
[01:28:10.440]                             name <- restart$name
[01:28:10.440]                             if (is.null(name)) 
[01:28:10.440]                               next
[01:28:10.440]                             if (!grepl(pattern, name)) 
[01:28:10.440]                               next
[01:28:10.440]                             invokeRestart(restart)
[01:28:10.440]                             muffled <- TRUE
[01:28:10.440]                             break
[01:28:10.440]                           }
[01:28:10.440]                         }
[01:28:10.440]                       }
[01:28:10.440]                       invisible(muffled)
[01:28:10.440]                     }
[01:28:10.440]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.440]                   }
[01:28:10.440]                 }
[01:28:10.440]             }
[01:28:10.440]         }))
[01:28:10.440]     }, error = function(ex) {
[01:28:10.440]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.440]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.440]                 ...future.rng), started = ...future.startTime, 
[01:28:10.440]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.440]             version = "1.8"), class = "FutureResult")
[01:28:10.440]     }, finally = {
[01:28:10.440]         if (!identical(...future.workdir, getwd())) 
[01:28:10.440]             setwd(...future.workdir)
[01:28:10.440]         {
[01:28:10.440]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.440]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.440]             }
[01:28:10.440]             base::options(...future.oldOptions)
[01:28:10.440]             if (.Platform$OS.type == "windows") {
[01:28:10.440]                 old_names <- names(...future.oldEnvVars)
[01:28:10.440]                 envs <- base::Sys.getenv()
[01:28:10.440]                 names <- names(envs)
[01:28:10.440]                 common <- intersect(names, old_names)
[01:28:10.440]                 added <- setdiff(names, old_names)
[01:28:10.440]                 removed <- setdiff(old_names, names)
[01:28:10.440]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.440]                   envs[common]]
[01:28:10.440]                 NAMES <- toupper(changed)
[01:28:10.440]                 args <- list()
[01:28:10.440]                 for (kk in seq_along(NAMES)) {
[01:28:10.440]                   name <- changed[[kk]]
[01:28:10.440]                   NAME <- NAMES[[kk]]
[01:28:10.440]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.440]                     next
[01:28:10.440]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.440]                 }
[01:28:10.440]                 NAMES <- toupper(added)
[01:28:10.440]                 for (kk in seq_along(NAMES)) {
[01:28:10.440]                   name <- added[[kk]]
[01:28:10.440]                   NAME <- NAMES[[kk]]
[01:28:10.440]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.440]                     next
[01:28:10.440]                   args[[name]] <- ""
[01:28:10.440]                 }
[01:28:10.440]                 NAMES <- toupper(removed)
[01:28:10.440]                 for (kk in seq_along(NAMES)) {
[01:28:10.440]                   name <- removed[[kk]]
[01:28:10.440]                   NAME <- NAMES[[kk]]
[01:28:10.440]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.440]                     next
[01:28:10.440]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.440]                 }
[01:28:10.440]                 if (length(args) > 0) 
[01:28:10.440]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.440]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.440]             }
[01:28:10.440]             else {
[01:28:10.440]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.440]             }
[01:28:10.440]             {
[01:28:10.440]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.440]                   0L) {
[01:28:10.440]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.440]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.440]                   base::options(opts)
[01:28:10.440]                 }
[01:28:10.440]                 {
[01:28:10.440]                   {
[01:28:10.440]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.440]                     NULL
[01:28:10.440]                   }
[01:28:10.440]                   options(future.plan = NULL)
[01:28:10.440]                   if (is.na(NA_character_)) 
[01:28:10.440]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.440]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.440]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.440]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.440]                     envir = parent.frame()) 
[01:28:10.440]                   {
[01:28:10.440]                     if (is.function(workers)) 
[01:28:10.440]                       workers <- workers()
[01:28:10.440]                     workers <- structure(as.integer(workers), 
[01:28:10.440]                       class = class(workers))
[01:28:10.440]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.440]                       workers >= 1)
[01:28:10.440]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.440]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.440]                     }
[01:28:10.440]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.440]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.440]                       envir = envir)
[01:28:10.440]                     if (!future$lazy) 
[01:28:10.440]                       future <- run(future)
[01:28:10.440]                     invisible(future)
[01:28:10.440]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.440]                 }
[01:28:10.440]             }
[01:28:10.440]         }
[01:28:10.440]     })
[01:28:10.440]     if (TRUE) {
[01:28:10.440]         base::sink(type = "output", split = FALSE)
[01:28:10.440]         if (TRUE) {
[01:28:10.440]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.440]         }
[01:28:10.440]         else {
[01:28:10.440]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.440]         }
[01:28:10.440]         base::close(...future.stdout)
[01:28:10.440]         ...future.stdout <- NULL
[01:28:10.440]     }
[01:28:10.440]     ...future.result$conditions <- ...future.conditions
[01:28:10.440]     ...future.result$finished <- base::Sys.time()
[01:28:10.440]     ...future.result
[01:28:10.440] }
[01:28:10.446] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[01:28:10.446] Exporting 'a' (56 bytes) to cluster node #2 ...
[01:28:10.447] Exporting 'a' (56 bytes) to cluster node #2 ... DONE
[01:28:10.447] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[01:28:10.447] MultisessionFuture started
[01:28:10.448] - Launch lazy future ... done
[01:28:10.448] run() for 'MultisessionFuture' ... done
[01:28:10.448] result() for ClusterFuture ...
[01:28:10.448] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.448] - Validating connection of MultisessionFuture
[01:28:10.476] - received message: FutureResult
[01:28:10.477] - Received FutureResult
[01:28:10.477] - Erased future from FutureRegistry
[01:28:10.477] result() for ClusterFuture ...
[01:28:10.477] - result already collected: FutureResult
[01:28:10.477] result() for ClusterFuture ... done
[01:28:10.478] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.478] result() for ClusterFuture ... done
[01:28:10.478] result() for ClusterFuture ...
[01:28:10.478] - result already collected: FutureResult
[01:28:10.478] result() for ClusterFuture ... done
y = 6
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.479] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.480] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.486] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.486] Searching for globals ... DONE
[01:28:10.486] Resolving globals: TRUE
[01:28:10.486] Resolving any globals that are futures ...
[01:28:10.486] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.486] Resolving any globals that are futures ... DONE
[01:28:10.487] Resolving futures part of globals (recursively) ...
[01:28:10.487] resolve() on list ...
[01:28:10.487]  recursive: 99
[01:28:10.488]  length: 2
[01:28:10.488]  elements: 'a', 'ii'
[01:28:10.488]  length: 1 (resolved future 1)
[01:28:10.488]  length: 0 (resolved future 2)
[01:28:10.488] resolve() on list ... DONE
[01:28:10.488] - globals: [2] 'a', 'ii'
[01:28:10.489] Resolving futures part of globals (recursively) ... DONE
[01:28:10.489] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:10.489] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:10.490] - globals: [2] 'a', 'ii'
[01:28:10.490] 
[01:28:10.490] getGlobalsAndPackages() ... DONE
[01:28:10.490] run() for 'Future' ...
[01:28:10.491] - state: 'created'
[01:28:10.491] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.505] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.505] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.505]   - Field: 'node'
[01:28:10.505]   - Field: 'label'
[01:28:10.506]   - Field: 'local'
[01:28:10.506]   - Field: 'owner'
[01:28:10.506]   - Field: 'envir'
[01:28:10.506]   - Field: 'workers'
[01:28:10.506]   - Field: 'packages'
[01:28:10.507]   - Field: 'gc'
[01:28:10.507]   - Field: 'conditions'
[01:28:10.507]   - Field: 'persistent'
[01:28:10.507]   - Field: 'expr'
[01:28:10.507]   - Field: 'uuid'
[01:28:10.507]   - Field: 'seed'
[01:28:10.508]   - Field: 'version'
[01:28:10.508]   - Field: 'result'
[01:28:10.508]   - Field: 'asynchronous'
[01:28:10.508]   - Field: 'calls'
[01:28:10.508]   - Field: 'globals'
[01:28:10.508]   - Field: 'stdout'
[01:28:10.509]   - Field: 'earlySignal'
[01:28:10.509]   - Field: 'lazy'
[01:28:10.509]   - Field: 'state'
[01:28:10.509] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.509] - Launch lazy future ...
[01:28:10.510] Packages needed by the future expression (n = 0): <none>
[01:28:10.510] Packages needed by future strategies (n = 0): <none>
[01:28:10.511] {
[01:28:10.511]     {
[01:28:10.511]         {
[01:28:10.511]             ...future.startTime <- base::Sys.time()
[01:28:10.511]             {
[01:28:10.511]                 {
[01:28:10.511]                   {
[01:28:10.511]                     {
[01:28:10.511]                       base::local({
[01:28:10.511]                         has_future <- base::requireNamespace("future", 
[01:28:10.511]                           quietly = TRUE)
[01:28:10.511]                         if (has_future) {
[01:28:10.511]                           ns <- base::getNamespace("future")
[01:28:10.511]                           version <- ns[[".package"]][["version"]]
[01:28:10.511]                           if (is.null(version)) 
[01:28:10.511]                             version <- utils::packageVersion("future")
[01:28:10.511]                         }
[01:28:10.511]                         else {
[01:28:10.511]                           version <- NULL
[01:28:10.511]                         }
[01:28:10.511]                         if (!has_future || version < "1.8.0") {
[01:28:10.511]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.511]                             "", base::R.version$version.string), 
[01:28:10.511]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.511]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.511]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.511]                               "release", "version")], collapse = " "), 
[01:28:10.511]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.511]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.511]                             info)
[01:28:10.511]                           info <- base::paste(info, collapse = "; ")
[01:28:10.511]                           if (!has_future) {
[01:28:10.511]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.511]                               info)
[01:28:10.511]                           }
[01:28:10.511]                           else {
[01:28:10.511]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.511]                               info, version)
[01:28:10.511]                           }
[01:28:10.511]                           base::stop(msg)
[01:28:10.511]                         }
[01:28:10.511]                       })
[01:28:10.511]                     }
[01:28:10.511]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.511]                     base::options(mc.cores = 1L)
[01:28:10.511]                   }
[01:28:10.511]                   options(future.plan = NULL)
[01:28:10.511]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.511]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.511]                 }
[01:28:10.511]                 ...future.workdir <- getwd()
[01:28:10.511]             }
[01:28:10.511]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.511]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.511]         }
[01:28:10.511]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.511]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.511]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.511]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.511]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.511]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.511]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.511]             base::names(...future.oldOptions))
[01:28:10.511]     }
[01:28:10.511]     if (FALSE) {
[01:28:10.511]     }
[01:28:10.511]     else {
[01:28:10.511]         if (TRUE) {
[01:28:10.511]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.511]                 open = "w")
[01:28:10.511]         }
[01:28:10.511]         else {
[01:28:10.511]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.511]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.511]         }
[01:28:10.511]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.511]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.511]             base::sink(type = "output", split = FALSE)
[01:28:10.511]             base::close(...future.stdout)
[01:28:10.511]         }, add = TRUE)
[01:28:10.511]     }
[01:28:10.511]     ...future.frame <- base::sys.nframe()
[01:28:10.511]     ...future.conditions <- base::list()
[01:28:10.511]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.511]     if (FALSE) {
[01:28:10.511]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.511]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.511]     }
[01:28:10.511]     ...future.result <- base::tryCatch({
[01:28:10.511]         base::withCallingHandlers({
[01:28:10.511]             ...future.value <- base::withVisible(base::local({
[01:28:10.511]                 ...future.makeSendCondition <- base::local({
[01:28:10.511]                   sendCondition <- NULL
[01:28:10.511]                   function(frame = 1L) {
[01:28:10.511]                     if (is.function(sendCondition)) 
[01:28:10.511]                       return(sendCondition)
[01:28:10.511]                     ns <- getNamespace("parallel")
[01:28:10.511]                     if (exists("sendData", mode = "function", 
[01:28:10.511]                       envir = ns)) {
[01:28:10.511]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.511]                         envir = ns)
[01:28:10.511]                       envir <- sys.frame(frame)
[01:28:10.511]                       master <- NULL
[01:28:10.511]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.511]                         !identical(envir, emptyenv())) {
[01:28:10.511]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.511]                           inherits = FALSE)) {
[01:28:10.511]                           master <- get("master", mode = "list", 
[01:28:10.511]                             envir = envir, inherits = FALSE)
[01:28:10.511]                           if (inherits(master, c("SOCKnode", 
[01:28:10.511]                             "SOCK0node"))) {
[01:28:10.511]                             sendCondition <<- function(cond) {
[01:28:10.511]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.511]                                 success = TRUE)
[01:28:10.511]                               parallel_sendData(master, data)
[01:28:10.511]                             }
[01:28:10.511]                             return(sendCondition)
[01:28:10.511]                           }
[01:28:10.511]                         }
[01:28:10.511]                         frame <- frame + 1L
[01:28:10.511]                         envir <- sys.frame(frame)
[01:28:10.511]                       }
[01:28:10.511]                     }
[01:28:10.511]                     sendCondition <<- function(cond) NULL
[01:28:10.511]                   }
[01:28:10.511]                 })
[01:28:10.511]                 withCallingHandlers({
[01:28:10.511]                   {
[01:28:10.511]                     b <- a * ii
[01:28:10.511]                     a <- 0
[01:28:10.511]                     b
[01:28:10.511]                   }
[01:28:10.511]                 }, immediateCondition = function(cond) {
[01:28:10.511]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.511]                   sendCondition(cond)
[01:28:10.511]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.511]                   {
[01:28:10.511]                     inherits <- base::inherits
[01:28:10.511]                     invokeRestart <- base::invokeRestart
[01:28:10.511]                     is.null <- base::is.null
[01:28:10.511]                     muffled <- FALSE
[01:28:10.511]                     if (inherits(cond, "message")) {
[01:28:10.511]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.511]                       if (muffled) 
[01:28:10.511]                         invokeRestart("muffleMessage")
[01:28:10.511]                     }
[01:28:10.511]                     else if (inherits(cond, "warning")) {
[01:28:10.511]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.511]                       if (muffled) 
[01:28:10.511]                         invokeRestart("muffleWarning")
[01:28:10.511]                     }
[01:28:10.511]                     else if (inherits(cond, "condition")) {
[01:28:10.511]                       if (!is.null(pattern)) {
[01:28:10.511]                         computeRestarts <- base::computeRestarts
[01:28:10.511]                         grepl <- base::grepl
[01:28:10.511]                         restarts <- computeRestarts(cond)
[01:28:10.511]                         for (restart in restarts) {
[01:28:10.511]                           name <- restart$name
[01:28:10.511]                           if (is.null(name)) 
[01:28:10.511]                             next
[01:28:10.511]                           if (!grepl(pattern, name)) 
[01:28:10.511]                             next
[01:28:10.511]                           invokeRestart(restart)
[01:28:10.511]                           muffled <- TRUE
[01:28:10.511]                           break
[01:28:10.511]                         }
[01:28:10.511]                       }
[01:28:10.511]                     }
[01:28:10.511]                     invisible(muffled)
[01:28:10.511]                   }
[01:28:10.511]                   muffleCondition(cond)
[01:28:10.511]                 })
[01:28:10.511]             }))
[01:28:10.511]             future::FutureResult(value = ...future.value$value, 
[01:28:10.511]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.511]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.511]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.511]                     ...future.globalenv.names))
[01:28:10.511]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.511]         }, condition = base::local({
[01:28:10.511]             c <- base::c
[01:28:10.511]             inherits <- base::inherits
[01:28:10.511]             invokeRestart <- base::invokeRestart
[01:28:10.511]             length <- base::length
[01:28:10.511]             list <- base::list
[01:28:10.511]             seq.int <- base::seq.int
[01:28:10.511]             signalCondition <- base::signalCondition
[01:28:10.511]             sys.calls <- base::sys.calls
[01:28:10.511]             `[[` <- base::`[[`
[01:28:10.511]             `+` <- base::`+`
[01:28:10.511]             `<<-` <- base::`<<-`
[01:28:10.511]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.511]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.511]                   3L)]
[01:28:10.511]             }
[01:28:10.511]             function(cond) {
[01:28:10.511]                 is_error <- inherits(cond, "error")
[01:28:10.511]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.511]                   NULL)
[01:28:10.511]                 if (is_error) {
[01:28:10.511]                   sessionInformation <- function() {
[01:28:10.511]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.511]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.511]                       search = base::search(), system = base::Sys.info())
[01:28:10.511]                   }
[01:28:10.511]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.511]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.511]                     cond$call), session = sessionInformation(), 
[01:28:10.511]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.511]                   signalCondition(cond)
[01:28:10.511]                 }
[01:28:10.511]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.511]                 "immediateCondition"))) {
[01:28:10.511]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.511]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.511]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.511]                   if (TRUE && !signal) {
[01:28:10.511]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.511]                     {
[01:28:10.511]                       inherits <- base::inherits
[01:28:10.511]                       invokeRestart <- base::invokeRestart
[01:28:10.511]                       is.null <- base::is.null
[01:28:10.511]                       muffled <- FALSE
[01:28:10.511]                       if (inherits(cond, "message")) {
[01:28:10.511]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.511]                         if (muffled) 
[01:28:10.511]                           invokeRestart("muffleMessage")
[01:28:10.511]                       }
[01:28:10.511]                       else if (inherits(cond, "warning")) {
[01:28:10.511]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.511]                         if (muffled) 
[01:28:10.511]                           invokeRestart("muffleWarning")
[01:28:10.511]                       }
[01:28:10.511]                       else if (inherits(cond, "condition")) {
[01:28:10.511]                         if (!is.null(pattern)) {
[01:28:10.511]                           computeRestarts <- base::computeRestarts
[01:28:10.511]                           grepl <- base::grepl
[01:28:10.511]                           restarts <- computeRestarts(cond)
[01:28:10.511]                           for (restart in restarts) {
[01:28:10.511]                             name <- restart$name
[01:28:10.511]                             if (is.null(name)) 
[01:28:10.511]                               next
[01:28:10.511]                             if (!grepl(pattern, name)) 
[01:28:10.511]                               next
[01:28:10.511]                             invokeRestart(restart)
[01:28:10.511]                             muffled <- TRUE
[01:28:10.511]                             break
[01:28:10.511]                           }
[01:28:10.511]                         }
[01:28:10.511]                       }
[01:28:10.511]                       invisible(muffled)
[01:28:10.511]                     }
[01:28:10.511]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.511]                   }
[01:28:10.511]                 }
[01:28:10.511]                 else {
[01:28:10.511]                   if (TRUE) {
[01:28:10.511]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.511]                     {
[01:28:10.511]                       inherits <- base::inherits
[01:28:10.511]                       invokeRestart <- base::invokeRestart
[01:28:10.511]                       is.null <- base::is.null
[01:28:10.511]                       muffled <- FALSE
[01:28:10.511]                       if (inherits(cond, "message")) {
[01:28:10.511]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.511]                         if (muffled) 
[01:28:10.511]                           invokeRestart("muffleMessage")
[01:28:10.511]                       }
[01:28:10.511]                       else if (inherits(cond, "warning")) {
[01:28:10.511]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.511]                         if (muffled) 
[01:28:10.511]                           invokeRestart("muffleWarning")
[01:28:10.511]                       }
[01:28:10.511]                       else if (inherits(cond, "condition")) {
[01:28:10.511]                         if (!is.null(pattern)) {
[01:28:10.511]                           computeRestarts <- base::computeRestarts
[01:28:10.511]                           grepl <- base::grepl
[01:28:10.511]                           restarts <- computeRestarts(cond)
[01:28:10.511]                           for (restart in restarts) {
[01:28:10.511]                             name <- restart$name
[01:28:10.511]                             if (is.null(name)) 
[01:28:10.511]                               next
[01:28:10.511]                             if (!grepl(pattern, name)) 
[01:28:10.511]                               next
[01:28:10.511]                             invokeRestart(restart)
[01:28:10.511]                             muffled <- TRUE
[01:28:10.511]                             break
[01:28:10.511]                           }
[01:28:10.511]                         }
[01:28:10.511]                       }
[01:28:10.511]                       invisible(muffled)
[01:28:10.511]                     }
[01:28:10.511]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.511]                   }
[01:28:10.511]                 }
[01:28:10.511]             }
[01:28:10.511]         }))
[01:28:10.511]     }, error = function(ex) {
[01:28:10.511]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.511]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.511]                 ...future.rng), started = ...future.startTime, 
[01:28:10.511]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.511]             version = "1.8"), class = "FutureResult")
[01:28:10.511]     }, finally = {
[01:28:10.511]         if (!identical(...future.workdir, getwd())) 
[01:28:10.511]             setwd(...future.workdir)
[01:28:10.511]         {
[01:28:10.511]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.511]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.511]             }
[01:28:10.511]             base::options(...future.oldOptions)
[01:28:10.511]             if (.Platform$OS.type == "windows") {
[01:28:10.511]                 old_names <- names(...future.oldEnvVars)
[01:28:10.511]                 envs <- base::Sys.getenv()
[01:28:10.511]                 names <- names(envs)
[01:28:10.511]                 common <- intersect(names, old_names)
[01:28:10.511]                 added <- setdiff(names, old_names)
[01:28:10.511]                 removed <- setdiff(old_names, names)
[01:28:10.511]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.511]                   envs[common]]
[01:28:10.511]                 NAMES <- toupper(changed)
[01:28:10.511]                 args <- list()
[01:28:10.511]                 for (kk in seq_along(NAMES)) {
[01:28:10.511]                   name <- changed[[kk]]
[01:28:10.511]                   NAME <- NAMES[[kk]]
[01:28:10.511]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.511]                     next
[01:28:10.511]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.511]                 }
[01:28:10.511]                 NAMES <- toupper(added)
[01:28:10.511]                 for (kk in seq_along(NAMES)) {
[01:28:10.511]                   name <- added[[kk]]
[01:28:10.511]                   NAME <- NAMES[[kk]]
[01:28:10.511]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.511]                     next
[01:28:10.511]                   args[[name]] <- ""
[01:28:10.511]                 }
[01:28:10.511]                 NAMES <- toupper(removed)
[01:28:10.511]                 for (kk in seq_along(NAMES)) {
[01:28:10.511]                   name <- removed[[kk]]
[01:28:10.511]                   NAME <- NAMES[[kk]]
[01:28:10.511]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.511]                     next
[01:28:10.511]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.511]                 }
[01:28:10.511]                 if (length(args) > 0) 
[01:28:10.511]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.511]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.511]             }
[01:28:10.511]             else {
[01:28:10.511]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.511]             }
[01:28:10.511]             {
[01:28:10.511]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.511]                   0L) {
[01:28:10.511]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.511]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.511]                   base::options(opts)
[01:28:10.511]                 }
[01:28:10.511]                 {
[01:28:10.511]                   {
[01:28:10.511]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.511]                     NULL
[01:28:10.511]                   }
[01:28:10.511]                   options(future.plan = NULL)
[01:28:10.511]                   if (is.na(NA_character_)) 
[01:28:10.511]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.511]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.511]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.511]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.511]                     envir = parent.frame()) 
[01:28:10.511]                   {
[01:28:10.511]                     if (is.function(workers)) 
[01:28:10.511]                       workers <- workers()
[01:28:10.511]                     workers <- structure(as.integer(workers), 
[01:28:10.511]                       class = class(workers))
[01:28:10.511]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.511]                       workers >= 1)
[01:28:10.511]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.511]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.511]                     }
[01:28:10.511]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.511]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.511]                       envir = envir)
[01:28:10.511]                     if (!future$lazy) 
[01:28:10.511]                       future <- run(future)
[01:28:10.511]                     invisible(future)
[01:28:10.511]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.511]                 }
[01:28:10.511]             }
[01:28:10.511]         }
[01:28:10.511]     })
[01:28:10.511]     if (TRUE) {
[01:28:10.511]         base::sink(type = "output", split = FALSE)
[01:28:10.511]         if (TRUE) {
[01:28:10.511]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.511]         }
[01:28:10.511]         else {
[01:28:10.511]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.511]         }
[01:28:10.511]         base::close(...future.stdout)
[01:28:10.511]         ...future.stdout <- NULL
[01:28:10.511]     }
[01:28:10.511]     ...future.result$conditions <- ...future.conditions
[01:28:10.511]     ...future.result$finished <- base::Sys.time()
[01:28:10.511]     ...future.result
[01:28:10.511] }
[01:28:10.516] Exporting 2 global objects (112 bytes) to cluster node #2 ...
[01:28:10.516] Exporting 'a' (56 bytes) to cluster node #2 ...
[01:28:10.516] Exporting 'a' (56 bytes) to cluster node #2 ... DONE
[01:28:10.517] Exporting 'ii' (56 bytes) to cluster node #2 ...
[01:28:10.517] Exporting 'ii' (56 bytes) to cluster node #2 ... DONE
[01:28:10.517] Exporting 2 global objects (112 bytes) to cluster node #2 ... DONE
[01:28:10.518] MultisessionFuture started
[01:28:10.518] - Launch lazy future ... done
[01:28:10.518] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.519] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.519] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.522] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.523] Searching for globals ... DONE
[01:28:10.523] Resolving globals: TRUE
[01:28:10.523] Resolving any globals that are futures ...
[01:28:10.523] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.523] Resolving any globals that are futures ... DONE
[01:28:10.524] Resolving futures part of globals (recursively) ...
[01:28:10.524] resolve() on list ...
[01:28:10.524]  recursive: 99
[01:28:10.524]  length: 2
[01:28:10.525]  elements: 'a', 'ii'
[01:28:10.525]  length: 1 (resolved future 1)
[01:28:10.525]  length: 0 (resolved future 2)
[01:28:10.525] resolve() on list ... DONE
[01:28:10.525] - globals: [2] 'a', 'ii'
[01:28:10.525] Resolving futures part of globals (recursively) ... DONE
[01:28:10.526] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:10.526] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:10.527] - globals: [2] 'a', 'ii'
[01:28:10.527] 
[01:28:10.527] getGlobalsAndPackages() ... DONE
[01:28:10.528] run() for 'Future' ...
[01:28:10.528] - state: 'created'
[01:28:10.528] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.543] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.544] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.544]   - Field: 'node'
[01:28:10.544]   - Field: 'label'
[01:28:10.544]   - Field: 'local'
[01:28:10.544]   - Field: 'owner'
[01:28:10.544]   - Field: 'envir'
[01:28:10.545]   - Field: 'workers'
[01:28:10.545]   - Field: 'packages'
[01:28:10.545]   - Field: 'gc'
[01:28:10.545]   - Field: 'conditions'
[01:28:10.545]   - Field: 'persistent'
[01:28:10.546]   - Field: 'expr'
[01:28:10.546]   - Field: 'uuid'
[01:28:10.546]   - Field: 'seed'
[01:28:10.546]   - Field: 'version'
[01:28:10.546]   - Field: 'result'
[01:28:10.546]   - Field: 'asynchronous'
[01:28:10.547]   - Field: 'calls'
[01:28:10.547]   - Field: 'globals'
[01:28:10.547]   - Field: 'stdout'
[01:28:10.547]   - Field: 'earlySignal'
[01:28:10.547]   - Field: 'lazy'
[01:28:10.547]   - Field: 'state'
[01:28:10.548] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.548] - Launch lazy future ...
[01:28:10.548] Packages needed by the future expression (n = 0): <none>
[01:28:10.548] Packages needed by future strategies (n = 0): <none>
[01:28:10.549] {
[01:28:10.549]     {
[01:28:10.549]         {
[01:28:10.549]             ...future.startTime <- base::Sys.time()
[01:28:10.549]             {
[01:28:10.549]                 {
[01:28:10.549]                   {
[01:28:10.549]                     {
[01:28:10.549]                       base::local({
[01:28:10.549]                         has_future <- base::requireNamespace("future", 
[01:28:10.549]                           quietly = TRUE)
[01:28:10.549]                         if (has_future) {
[01:28:10.549]                           ns <- base::getNamespace("future")
[01:28:10.549]                           version <- ns[[".package"]][["version"]]
[01:28:10.549]                           if (is.null(version)) 
[01:28:10.549]                             version <- utils::packageVersion("future")
[01:28:10.549]                         }
[01:28:10.549]                         else {
[01:28:10.549]                           version <- NULL
[01:28:10.549]                         }
[01:28:10.549]                         if (!has_future || version < "1.8.0") {
[01:28:10.549]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.549]                             "", base::R.version$version.string), 
[01:28:10.549]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.549]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.549]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.549]                               "release", "version")], collapse = " "), 
[01:28:10.549]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.549]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.549]                             info)
[01:28:10.549]                           info <- base::paste(info, collapse = "; ")
[01:28:10.549]                           if (!has_future) {
[01:28:10.549]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.549]                               info)
[01:28:10.549]                           }
[01:28:10.549]                           else {
[01:28:10.549]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.549]                               info, version)
[01:28:10.549]                           }
[01:28:10.549]                           base::stop(msg)
[01:28:10.549]                         }
[01:28:10.549]                       })
[01:28:10.549]                     }
[01:28:10.549]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.549]                     base::options(mc.cores = 1L)
[01:28:10.549]                   }
[01:28:10.549]                   options(future.plan = NULL)
[01:28:10.549]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.549]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.549]                 }
[01:28:10.549]                 ...future.workdir <- getwd()
[01:28:10.549]             }
[01:28:10.549]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.549]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.549]         }
[01:28:10.549]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.549]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.549]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.549]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.549]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.549]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.549]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.549]             base::names(...future.oldOptions))
[01:28:10.549]     }
[01:28:10.549]     if (FALSE) {
[01:28:10.549]     }
[01:28:10.549]     else {
[01:28:10.549]         if (TRUE) {
[01:28:10.549]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.549]                 open = "w")
[01:28:10.549]         }
[01:28:10.549]         else {
[01:28:10.549]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.549]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.549]         }
[01:28:10.549]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.549]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.549]             base::sink(type = "output", split = FALSE)
[01:28:10.549]             base::close(...future.stdout)
[01:28:10.549]         }, add = TRUE)
[01:28:10.549]     }
[01:28:10.549]     ...future.frame <- base::sys.nframe()
[01:28:10.549]     ...future.conditions <- base::list()
[01:28:10.549]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.549]     if (FALSE) {
[01:28:10.549]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.549]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.549]     }
[01:28:10.549]     ...future.result <- base::tryCatch({
[01:28:10.549]         base::withCallingHandlers({
[01:28:10.549]             ...future.value <- base::withVisible(base::local({
[01:28:10.549]                 ...future.makeSendCondition <- base::local({
[01:28:10.549]                   sendCondition <- NULL
[01:28:10.549]                   function(frame = 1L) {
[01:28:10.549]                     if (is.function(sendCondition)) 
[01:28:10.549]                       return(sendCondition)
[01:28:10.549]                     ns <- getNamespace("parallel")
[01:28:10.549]                     if (exists("sendData", mode = "function", 
[01:28:10.549]                       envir = ns)) {
[01:28:10.549]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.549]                         envir = ns)
[01:28:10.549]                       envir <- sys.frame(frame)
[01:28:10.549]                       master <- NULL
[01:28:10.549]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.549]                         !identical(envir, emptyenv())) {
[01:28:10.549]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.549]                           inherits = FALSE)) {
[01:28:10.549]                           master <- get("master", mode = "list", 
[01:28:10.549]                             envir = envir, inherits = FALSE)
[01:28:10.549]                           if (inherits(master, c("SOCKnode", 
[01:28:10.549]                             "SOCK0node"))) {
[01:28:10.549]                             sendCondition <<- function(cond) {
[01:28:10.549]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.549]                                 success = TRUE)
[01:28:10.549]                               parallel_sendData(master, data)
[01:28:10.549]                             }
[01:28:10.549]                             return(sendCondition)
[01:28:10.549]                           }
[01:28:10.549]                         }
[01:28:10.549]                         frame <- frame + 1L
[01:28:10.549]                         envir <- sys.frame(frame)
[01:28:10.549]                       }
[01:28:10.549]                     }
[01:28:10.549]                     sendCondition <<- function(cond) NULL
[01:28:10.549]                   }
[01:28:10.549]                 })
[01:28:10.549]                 withCallingHandlers({
[01:28:10.549]                   {
[01:28:10.549]                     b <- a * ii
[01:28:10.549]                     a <- 0
[01:28:10.549]                     b
[01:28:10.549]                   }
[01:28:10.549]                 }, immediateCondition = function(cond) {
[01:28:10.549]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.549]                   sendCondition(cond)
[01:28:10.549]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.549]                   {
[01:28:10.549]                     inherits <- base::inherits
[01:28:10.549]                     invokeRestart <- base::invokeRestart
[01:28:10.549]                     is.null <- base::is.null
[01:28:10.549]                     muffled <- FALSE
[01:28:10.549]                     if (inherits(cond, "message")) {
[01:28:10.549]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.549]                       if (muffled) 
[01:28:10.549]                         invokeRestart("muffleMessage")
[01:28:10.549]                     }
[01:28:10.549]                     else if (inherits(cond, "warning")) {
[01:28:10.549]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.549]                       if (muffled) 
[01:28:10.549]                         invokeRestart("muffleWarning")
[01:28:10.549]                     }
[01:28:10.549]                     else if (inherits(cond, "condition")) {
[01:28:10.549]                       if (!is.null(pattern)) {
[01:28:10.549]                         computeRestarts <- base::computeRestarts
[01:28:10.549]                         grepl <- base::grepl
[01:28:10.549]                         restarts <- computeRestarts(cond)
[01:28:10.549]                         for (restart in restarts) {
[01:28:10.549]                           name <- restart$name
[01:28:10.549]                           if (is.null(name)) 
[01:28:10.549]                             next
[01:28:10.549]                           if (!grepl(pattern, name)) 
[01:28:10.549]                             next
[01:28:10.549]                           invokeRestart(restart)
[01:28:10.549]                           muffled <- TRUE
[01:28:10.549]                           break
[01:28:10.549]                         }
[01:28:10.549]                       }
[01:28:10.549]                     }
[01:28:10.549]                     invisible(muffled)
[01:28:10.549]                   }
[01:28:10.549]                   muffleCondition(cond)
[01:28:10.549]                 })
[01:28:10.549]             }))
[01:28:10.549]             future::FutureResult(value = ...future.value$value, 
[01:28:10.549]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.549]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.549]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.549]                     ...future.globalenv.names))
[01:28:10.549]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.549]         }, condition = base::local({
[01:28:10.549]             c <- base::c
[01:28:10.549]             inherits <- base::inherits
[01:28:10.549]             invokeRestart <- base::invokeRestart
[01:28:10.549]             length <- base::length
[01:28:10.549]             list <- base::list
[01:28:10.549]             seq.int <- base::seq.int
[01:28:10.549]             signalCondition <- base::signalCondition
[01:28:10.549]             sys.calls <- base::sys.calls
[01:28:10.549]             `[[` <- base::`[[`
[01:28:10.549]             `+` <- base::`+`
[01:28:10.549]             `<<-` <- base::`<<-`
[01:28:10.549]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.549]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.549]                   3L)]
[01:28:10.549]             }
[01:28:10.549]             function(cond) {
[01:28:10.549]                 is_error <- inherits(cond, "error")
[01:28:10.549]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.549]                   NULL)
[01:28:10.549]                 if (is_error) {
[01:28:10.549]                   sessionInformation <- function() {
[01:28:10.549]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.549]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.549]                       search = base::search(), system = base::Sys.info())
[01:28:10.549]                   }
[01:28:10.549]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.549]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.549]                     cond$call), session = sessionInformation(), 
[01:28:10.549]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.549]                   signalCondition(cond)
[01:28:10.549]                 }
[01:28:10.549]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.549]                 "immediateCondition"))) {
[01:28:10.549]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.549]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.549]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.549]                   if (TRUE && !signal) {
[01:28:10.549]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.549]                     {
[01:28:10.549]                       inherits <- base::inherits
[01:28:10.549]                       invokeRestart <- base::invokeRestart
[01:28:10.549]                       is.null <- base::is.null
[01:28:10.549]                       muffled <- FALSE
[01:28:10.549]                       if (inherits(cond, "message")) {
[01:28:10.549]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.549]                         if (muffled) 
[01:28:10.549]                           invokeRestart("muffleMessage")
[01:28:10.549]                       }
[01:28:10.549]                       else if (inherits(cond, "warning")) {
[01:28:10.549]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.549]                         if (muffled) 
[01:28:10.549]                           invokeRestart("muffleWarning")
[01:28:10.549]                       }
[01:28:10.549]                       else if (inherits(cond, "condition")) {
[01:28:10.549]                         if (!is.null(pattern)) {
[01:28:10.549]                           computeRestarts <- base::computeRestarts
[01:28:10.549]                           grepl <- base::grepl
[01:28:10.549]                           restarts <- computeRestarts(cond)
[01:28:10.549]                           for (restart in restarts) {
[01:28:10.549]                             name <- restart$name
[01:28:10.549]                             if (is.null(name)) 
[01:28:10.549]                               next
[01:28:10.549]                             if (!grepl(pattern, name)) 
[01:28:10.549]                               next
[01:28:10.549]                             invokeRestart(restart)
[01:28:10.549]                             muffled <- TRUE
[01:28:10.549]                             break
[01:28:10.549]                           }
[01:28:10.549]                         }
[01:28:10.549]                       }
[01:28:10.549]                       invisible(muffled)
[01:28:10.549]                     }
[01:28:10.549]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.549]                   }
[01:28:10.549]                 }
[01:28:10.549]                 else {
[01:28:10.549]                   if (TRUE) {
[01:28:10.549]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.549]                     {
[01:28:10.549]                       inherits <- base::inherits
[01:28:10.549]                       invokeRestart <- base::invokeRestart
[01:28:10.549]                       is.null <- base::is.null
[01:28:10.549]                       muffled <- FALSE
[01:28:10.549]                       if (inherits(cond, "message")) {
[01:28:10.549]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.549]                         if (muffled) 
[01:28:10.549]                           invokeRestart("muffleMessage")
[01:28:10.549]                       }
[01:28:10.549]                       else if (inherits(cond, "warning")) {
[01:28:10.549]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.549]                         if (muffled) 
[01:28:10.549]                           invokeRestart("muffleWarning")
[01:28:10.549]                       }
[01:28:10.549]                       else if (inherits(cond, "condition")) {
[01:28:10.549]                         if (!is.null(pattern)) {
[01:28:10.549]                           computeRestarts <- base::computeRestarts
[01:28:10.549]                           grepl <- base::grepl
[01:28:10.549]                           restarts <- computeRestarts(cond)
[01:28:10.549]                           for (restart in restarts) {
[01:28:10.549]                             name <- restart$name
[01:28:10.549]                             if (is.null(name)) 
[01:28:10.549]                               next
[01:28:10.549]                             if (!grepl(pattern, name)) 
[01:28:10.549]                               next
[01:28:10.549]                             invokeRestart(restart)
[01:28:10.549]                             muffled <- TRUE
[01:28:10.549]                             break
[01:28:10.549]                           }
[01:28:10.549]                         }
[01:28:10.549]                       }
[01:28:10.549]                       invisible(muffled)
[01:28:10.549]                     }
[01:28:10.549]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.549]                   }
[01:28:10.549]                 }
[01:28:10.549]             }
[01:28:10.549]         }))
[01:28:10.549]     }, error = function(ex) {
[01:28:10.549]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.549]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.549]                 ...future.rng), started = ...future.startTime, 
[01:28:10.549]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.549]             version = "1.8"), class = "FutureResult")
[01:28:10.549]     }, finally = {
[01:28:10.549]         if (!identical(...future.workdir, getwd())) 
[01:28:10.549]             setwd(...future.workdir)
[01:28:10.549]         {
[01:28:10.549]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.549]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.549]             }
[01:28:10.549]             base::options(...future.oldOptions)
[01:28:10.549]             if (.Platform$OS.type == "windows") {
[01:28:10.549]                 old_names <- names(...future.oldEnvVars)
[01:28:10.549]                 envs <- base::Sys.getenv()
[01:28:10.549]                 names <- names(envs)
[01:28:10.549]                 common <- intersect(names, old_names)
[01:28:10.549]                 added <- setdiff(names, old_names)
[01:28:10.549]                 removed <- setdiff(old_names, names)
[01:28:10.549]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.549]                   envs[common]]
[01:28:10.549]                 NAMES <- toupper(changed)
[01:28:10.549]                 args <- list()
[01:28:10.549]                 for (kk in seq_along(NAMES)) {
[01:28:10.549]                   name <- changed[[kk]]
[01:28:10.549]                   NAME <- NAMES[[kk]]
[01:28:10.549]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.549]                     next
[01:28:10.549]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.549]                 }
[01:28:10.549]                 NAMES <- toupper(added)
[01:28:10.549]                 for (kk in seq_along(NAMES)) {
[01:28:10.549]                   name <- added[[kk]]
[01:28:10.549]                   NAME <- NAMES[[kk]]
[01:28:10.549]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.549]                     next
[01:28:10.549]                   args[[name]] <- ""
[01:28:10.549]                 }
[01:28:10.549]                 NAMES <- toupper(removed)
[01:28:10.549]                 for (kk in seq_along(NAMES)) {
[01:28:10.549]                   name <- removed[[kk]]
[01:28:10.549]                   NAME <- NAMES[[kk]]
[01:28:10.549]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.549]                     next
[01:28:10.549]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.549]                 }
[01:28:10.549]                 if (length(args) > 0) 
[01:28:10.549]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.549]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.549]             }
[01:28:10.549]             else {
[01:28:10.549]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.549]             }
[01:28:10.549]             {
[01:28:10.549]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.549]                   0L) {
[01:28:10.549]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.549]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.549]                   base::options(opts)
[01:28:10.549]                 }
[01:28:10.549]                 {
[01:28:10.549]                   {
[01:28:10.549]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.549]                     NULL
[01:28:10.549]                   }
[01:28:10.549]                   options(future.plan = NULL)
[01:28:10.549]                   if (is.na(NA_character_)) 
[01:28:10.549]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.549]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.549]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.549]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.549]                     envir = parent.frame()) 
[01:28:10.549]                   {
[01:28:10.549]                     if (is.function(workers)) 
[01:28:10.549]                       workers <- workers()
[01:28:10.549]                     workers <- structure(as.integer(workers), 
[01:28:10.549]                       class = class(workers))
[01:28:10.549]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.549]                       workers >= 1)
[01:28:10.549]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.549]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.549]                     }
[01:28:10.549]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.549]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.549]                       envir = envir)
[01:28:10.549]                     if (!future$lazy) 
[01:28:10.549]                       future <- run(future)
[01:28:10.549]                     invisible(future)
[01:28:10.549]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.549]                 }
[01:28:10.549]             }
[01:28:10.549]         }
[01:28:10.549]     })
[01:28:10.549]     if (TRUE) {
[01:28:10.549]         base::sink(type = "output", split = FALSE)
[01:28:10.549]         if (TRUE) {
[01:28:10.549]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.549]         }
[01:28:10.549]         else {
[01:28:10.549]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.549]         }
[01:28:10.549]         base::close(...future.stdout)
[01:28:10.549]         ...future.stdout <- NULL
[01:28:10.549]     }
[01:28:10.549]     ...future.result$conditions <- ...future.conditions
[01:28:10.549]     ...future.result$finished <- base::Sys.time()
[01:28:10.549]     ...future.result
[01:28:10.549] }
[01:28:10.554] Poll #1 (0): usedNodes() = 2, workers = 2
[01:28:10.573] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.573] - Validating connection of MultisessionFuture
[01:28:10.574] - received message: FutureResult
[01:28:10.574] - Received FutureResult
[01:28:10.574] - Erased future from FutureRegistry
[01:28:10.574] result() for ClusterFuture ...
[01:28:10.575] - result already collected: FutureResult
[01:28:10.575] result() for ClusterFuture ... done
[01:28:10.575] signalConditions() ...
[01:28:10.575]  - include = 'immediateCondition'
[01:28:10.575]  - exclude = 
[01:28:10.575]  - resignal = FALSE
[01:28:10.576]  - Number of conditions: 1
[01:28:10.576] signalConditions() ... done
[01:28:10.576] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.576] result() for ClusterFuture ...
[01:28:10.576] - result already collected: FutureResult
[01:28:10.576] result() for ClusterFuture ... done
[01:28:10.577] result() for ClusterFuture ...
[01:28:10.577] - result already collected: FutureResult
[01:28:10.577] result() for ClusterFuture ... done
[01:28:10.577] signalConditions() ...
[01:28:10.577]  - include = 'immediateCondition'
[01:28:10.577]  - exclude = 
[01:28:10.578]  - resignal = FALSE
[01:28:10.578]  - Number of conditions: 1
[01:28:10.578] signalConditions() ... done
[01:28:10.579] Exporting 2 global objects (112 bytes) to cluster node #1 ...
[01:28:10.579] Exporting 'a' (56 bytes) to cluster node #1 ...
[01:28:10.579] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[01:28:10.580] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:10.580] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:10.580] Exporting 2 global objects (112 bytes) to cluster node #1 ... DONE
[01:28:10.581] MultisessionFuture started
[01:28:10.581] - Launch lazy future ... done
[01:28:10.581] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.582] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.582] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.585] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.585] Searching for globals ... DONE
[01:28:10.585] Resolving globals: TRUE
[01:28:10.585] Resolving any globals that are futures ...
[01:28:10.586] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.586] Resolving any globals that are futures ... DONE
[01:28:10.586] Resolving futures part of globals (recursively) ...
[01:28:10.587] resolve() on list ...
[01:28:10.587]  recursive: 99
[01:28:10.587]  length: 2
[01:28:10.587]  elements: 'a', 'ii'
[01:28:10.587]  length: 1 (resolved future 1)
[01:28:10.588]  length: 0 (resolved future 2)
[01:28:10.588] resolve() on list ... DONE
[01:28:10.588] - globals: [2] 'a', 'ii'
[01:28:10.588] Resolving futures part of globals (recursively) ... DONE
[01:28:10.588] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:10.589] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:10.589] - globals: [2] 'a', 'ii'
[01:28:10.589] 
[01:28:10.589] getGlobalsAndPackages() ... DONE
[01:28:10.590] run() for 'Future' ...
[01:28:10.590] - state: 'created'
[01:28:10.590] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.605] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.605] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.605]   - Field: 'node'
[01:28:10.605]   - Field: 'label'
[01:28:10.605]   - Field: 'local'
[01:28:10.606]   - Field: 'owner'
[01:28:10.606]   - Field: 'envir'
[01:28:10.606]   - Field: 'workers'
[01:28:10.606]   - Field: 'packages'
[01:28:10.606]   - Field: 'gc'
[01:28:10.607]   - Field: 'conditions'
[01:28:10.607]   - Field: 'persistent'
[01:28:10.607]   - Field: 'expr'
[01:28:10.607]   - Field: 'uuid'
[01:28:10.607]   - Field: 'seed'
[01:28:10.607]   - Field: 'version'
[01:28:10.608]   - Field: 'result'
[01:28:10.608]   - Field: 'asynchronous'
[01:28:10.608]   - Field: 'calls'
[01:28:10.608]   - Field: 'globals'
[01:28:10.608]   - Field: 'stdout'
[01:28:10.608]   - Field: 'earlySignal'
[01:28:10.609]   - Field: 'lazy'
[01:28:10.609]   - Field: 'state'
[01:28:10.609] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.609] - Launch lazy future ...
[01:28:10.610] Packages needed by the future expression (n = 0): <none>
[01:28:10.610] Packages needed by future strategies (n = 0): <none>
[01:28:10.610] {
[01:28:10.610]     {
[01:28:10.610]         {
[01:28:10.610]             ...future.startTime <- base::Sys.time()
[01:28:10.610]             {
[01:28:10.610]                 {
[01:28:10.610]                   {
[01:28:10.610]                     {
[01:28:10.610]                       base::local({
[01:28:10.610]                         has_future <- base::requireNamespace("future", 
[01:28:10.610]                           quietly = TRUE)
[01:28:10.610]                         if (has_future) {
[01:28:10.610]                           ns <- base::getNamespace("future")
[01:28:10.610]                           version <- ns[[".package"]][["version"]]
[01:28:10.610]                           if (is.null(version)) 
[01:28:10.610]                             version <- utils::packageVersion("future")
[01:28:10.610]                         }
[01:28:10.610]                         else {
[01:28:10.610]                           version <- NULL
[01:28:10.610]                         }
[01:28:10.610]                         if (!has_future || version < "1.8.0") {
[01:28:10.610]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.610]                             "", base::R.version$version.string), 
[01:28:10.610]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.610]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.610]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.610]                               "release", "version")], collapse = " "), 
[01:28:10.610]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.610]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.610]                             info)
[01:28:10.610]                           info <- base::paste(info, collapse = "; ")
[01:28:10.610]                           if (!has_future) {
[01:28:10.610]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.610]                               info)
[01:28:10.610]                           }
[01:28:10.610]                           else {
[01:28:10.610]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.610]                               info, version)
[01:28:10.610]                           }
[01:28:10.610]                           base::stop(msg)
[01:28:10.610]                         }
[01:28:10.610]                       })
[01:28:10.610]                     }
[01:28:10.610]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.610]                     base::options(mc.cores = 1L)
[01:28:10.610]                   }
[01:28:10.610]                   options(future.plan = NULL)
[01:28:10.610]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.610]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.610]                 }
[01:28:10.610]                 ...future.workdir <- getwd()
[01:28:10.610]             }
[01:28:10.610]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.610]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.610]         }
[01:28:10.610]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.610]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.610]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.610]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.610]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.610]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.610]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.610]             base::names(...future.oldOptions))
[01:28:10.610]     }
[01:28:10.610]     if (FALSE) {
[01:28:10.610]     }
[01:28:10.610]     else {
[01:28:10.610]         if (TRUE) {
[01:28:10.610]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.610]                 open = "w")
[01:28:10.610]         }
[01:28:10.610]         else {
[01:28:10.610]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.610]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.610]         }
[01:28:10.610]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.610]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.610]             base::sink(type = "output", split = FALSE)
[01:28:10.610]             base::close(...future.stdout)
[01:28:10.610]         }, add = TRUE)
[01:28:10.610]     }
[01:28:10.610]     ...future.frame <- base::sys.nframe()
[01:28:10.610]     ...future.conditions <- base::list()
[01:28:10.610]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.610]     if (FALSE) {
[01:28:10.610]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.610]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.610]     }
[01:28:10.610]     ...future.result <- base::tryCatch({
[01:28:10.610]         base::withCallingHandlers({
[01:28:10.610]             ...future.value <- base::withVisible(base::local({
[01:28:10.610]                 ...future.makeSendCondition <- base::local({
[01:28:10.610]                   sendCondition <- NULL
[01:28:10.610]                   function(frame = 1L) {
[01:28:10.610]                     if (is.function(sendCondition)) 
[01:28:10.610]                       return(sendCondition)
[01:28:10.610]                     ns <- getNamespace("parallel")
[01:28:10.610]                     if (exists("sendData", mode = "function", 
[01:28:10.610]                       envir = ns)) {
[01:28:10.610]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.610]                         envir = ns)
[01:28:10.610]                       envir <- sys.frame(frame)
[01:28:10.610]                       master <- NULL
[01:28:10.610]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.610]                         !identical(envir, emptyenv())) {
[01:28:10.610]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.610]                           inherits = FALSE)) {
[01:28:10.610]                           master <- get("master", mode = "list", 
[01:28:10.610]                             envir = envir, inherits = FALSE)
[01:28:10.610]                           if (inherits(master, c("SOCKnode", 
[01:28:10.610]                             "SOCK0node"))) {
[01:28:10.610]                             sendCondition <<- function(cond) {
[01:28:10.610]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.610]                                 success = TRUE)
[01:28:10.610]                               parallel_sendData(master, data)
[01:28:10.610]                             }
[01:28:10.610]                             return(sendCondition)
[01:28:10.610]                           }
[01:28:10.610]                         }
[01:28:10.610]                         frame <- frame + 1L
[01:28:10.610]                         envir <- sys.frame(frame)
[01:28:10.610]                       }
[01:28:10.610]                     }
[01:28:10.610]                     sendCondition <<- function(cond) NULL
[01:28:10.610]                   }
[01:28:10.610]                 })
[01:28:10.610]                 withCallingHandlers({
[01:28:10.610]                   {
[01:28:10.610]                     b <- a * ii
[01:28:10.610]                     a <- 0
[01:28:10.610]                     b
[01:28:10.610]                   }
[01:28:10.610]                 }, immediateCondition = function(cond) {
[01:28:10.610]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.610]                   sendCondition(cond)
[01:28:10.610]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.610]                   {
[01:28:10.610]                     inherits <- base::inherits
[01:28:10.610]                     invokeRestart <- base::invokeRestart
[01:28:10.610]                     is.null <- base::is.null
[01:28:10.610]                     muffled <- FALSE
[01:28:10.610]                     if (inherits(cond, "message")) {
[01:28:10.610]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.610]                       if (muffled) 
[01:28:10.610]                         invokeRestart("muffleMessage")
[01:28:10.610]                     }
[01:28:10.610]                     else if (inherits(cond, "warning")) {
[01:28:10.610]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.610]                       if (muffled) 
[01:28:10.610]                         invokeRestart("muffleWarning")
[01:28:10.610]                     }
[01:28:10.610]                     else if (inherits(cond, "condition")) {
[01:28:10.610]                       if (!is.null(pattern)) {
[01:28:10.610]                         computeRestarts <- base::computeRestarts
[01:28:10.610]                         grepl <- base::grepl
[01:28:10.610]                         restarts <- computeRestarts(cond)
[01:28:10.610]                         for (restart in restarts) {
[01:28:10.610]                           name <- restart$name
[01:28:10.610]                           if (is.null(name)) 
[01:28:10.610]                             next
[01:28:10.610]                           if (!grepl(pattern, name)) 
[01:28:10.610]                             next
[01:28:10.610]                           invokeRestart(restart)
[01:28:10.610]                           muffled <- TRUE
[01:28:10.610]                           break
[01:28:10.610]                         }
[01:28:10.610]                       }
[01:28:10.610]                     }
[01:28:10.610]                     invisible(muffled)
[01:28:10.610]                   }
[01:28:10.610]                   muffleCondition(cond)
[01:28:10.610]                 })
[01:28:10.610]             }))
[01:28:10.610]             future::FutureResult(value = ...future.value$value, 
[01:28:10.610]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.610]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.610]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.610]                     ...future.globalenv.names))
[01:28:10.610]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.610]         }, condition = base::local({
[01:28:10.610]             c <- base::c
[01:28:10.610]             inherits <- base::inherits
[01:28:10.610]             invokeRestart <- base::invokeRestart
[01:28:10.610]             length <- base::length
[01:28:10.610]             list <- base::list
[01:28:10.610]             seq.int <- base::seq.int
[01:28:10.610]             signalCondition <- base::signalCondition
[01:28:10.610]             sys.calls <- base::sys.calls
[01:28:10.610]             `[[` <- base::`[[`
[01:28:10.610]             `+` <- base::`+`
[01:28:10.610]             `<<-` <- base::`<<-`
[01:28:10.610]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.610]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.610]                   3L)]
[01:28:10.610]             }
[01:28:10.610]             function(cond) {
[01:28:10.610]                 is_error <- inherits(cond, "error")
[01:28:10.610]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.610]                   NULL)
[01:28:10.610]                 if (is_error) {
[01:28:10.610]                   sessionInformation <- function() {
[01:28:10.610]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.610]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.610]                       search = base::search(), system = base::Sys.info())
[01:28:10.610]                   }
[01:28:10.610]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.610]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.610]                     cond$call), session = sessionInformation(), 
[01:28:10.610]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.610]                   signalCondition(cond)
[01:28:10.610]                 }
[01:28:10.610]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.610]                 "immediateCondition"))) {
[01:28:10.610]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.610]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.610]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.610]                   if (TRUE && !signal) {
[01:28:10.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.610]                     {
[01:28:10.610]                       inherits <- base::inherits
[01:28:10.610]                       invokeRestart <- base::invokeRestart
[01:28:10.610]                       is.null <- base::is.null
[01:28:10.610]                       muffled <- FALSE
[01:28:10.610]                       if (inherits(cond, "message")) {
[01:28:10.610]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.610]                         if (muffled) 
[01:28:10.610]                           invokeRestart("muffleMessage")
[01:28:10.610]                       }
[01:28:10.610]                       else if (inherits(cond, "warning")) {
[01:28:10.610]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.610]                         if (muffled) 
[01:28:10.610]                           invokeRestart("muffleWarning")
[01:28:10.610]                       }
[01:28:10.610]                       else if (inherits(cond, "condition")) {
[01:28:10.610]                         if (!is.null(pattern)) {
[01:28:10.610]                           computeRestarts <- base::computeRestarts
[01:28:10.610]                           grepl <- base::grepl
[01:28:10.610]                           restarts <- computeRestarts(cond)
[01:28:10.610]                           for (restart in restarts) {
[01:28:10.610]                             name <- restart$name
[01:28:10.610]                             if (is.null(name)) 
[01:28:10.610]                               next
[01:28:10.610]                             if (!grepl(pattern, name)) 
[01:28:10.610]                               next
[01:28:10.610]                             invokeRestart(restart)
[01:28:10.610]                             muffled <- TRUE
[01:28:10.610]                             break
[01:28:10.610]                           }
[01:28:10.610]                         }
[01:28:10.610]                       }
[01:28:10.610]                       invisible(muffled)
[01:28:10.610]                     }
[01:28:10.610]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.610]                   }
[01:28:10.610]                 }
[01:28:10.610]                 else {
[01:28:10.610]                   if (TRUE) {
[01:28:10.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.610]                     {
[01:28:10.610]                       inherits <- base::inherits
[01:28:10.610]                       invokeRestart <- base::invokeRestart
[01:28:10.610]                       is.null <- base::is.null
[01:28:10.610]                       muffled <- FALSE
[01:28:10.610]                       if (inherits(cond, "message")) {
[01:28:10.610]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.610]                         if (muffled) 
[01:28:10.610]                           invokeRestart("muffleMessage")
[01:28:10.610]                       }
[01:28:10.610]                       else if (inherits(cond, "warning")) {
[01:28:10.610]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.610]                         if (muffled) 
[01:28:10.610]                           invokeRestart("muffleWarning")
[01:28:10.610]                       }
[01:28:10.610]                       else if (inherits(cond, "condition")) {
[01:28:10.610]                         if (!is.null(pattern)) {
[01:28:10.610]                           computeRestarts <- base::computeRestarts
[01:28:10.610]                           grepl <- base::grepl
[01:28:10.610]                           restarts <- computeRestarts(cond)
[01:28:10.610]                           for (restart in restarts) {
[01:28:10.610]                             name <- restart$name
[01:28:10.610]                             if (is.null(name)) 
[01:28:10.610]                               next
[01:28:10.610]                             if (!grepl(pattern, name)) 
[01:28:10.610]                               next
[01:28:10.610]                             invokeRestart(restart)
[01:28:10.610]                             muffled <- TRUE
[01:28:10.610]                             break
[01:28:10.610]                           }
[01:28:10.610]                         }
[01:28:10.610]                       }
[01:28:10.610]                       invisible(muffled)
[01:28:10.610]                     }
[01:28:10.610]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.610]                   }
[01:28:10.610]                 }
[01:28:10.610]             }
[01:28:10.610]         }))
[01:28:10.610]     }, error = function(ex) {
[01:28:10.610]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.610]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.610]                 ...future.rng), started = ...future.startTime, 
[01:28:10.610]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.610]             version = "1.8"), class = "FutureResult")
[01:28:10.610]     }, finally = {
[01:28:10.610]         if (!identical(...future.workdir, getwd())) 
[01:28:10.610]             setwd(...future.workdir)
[01:28:10.610]         {
[01:28:10.610]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.610]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.610]             }
[01:28:10.610]             base::options(...future.oldOptions)
[01:28:10.610]             if (.Platform$OS.type == "windows") {
[01:28:10.610]                 old_names <- names(...future.oldEnvVars)
[01:28:10.610]                 envs <- base::Sys.getenv()
[01:28:10.610]                 names <- names(envs)
[01:28:10.610]                 common <- intersect(names, old_names)
[01:28:10.610]                 added <- setdiff(names, old_names)
[01:28:10.610]                 removed <- setdiff(old_names, names)
[01:28:10.610]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.610]                   envs[common]]
[01:28:10.610]                 NAMES <- toupper(changed)
[01:28:10.610]                 args <- list()
[01:28:10.610]                 for (kk in seq_along(NAMES)) {
[01:28:10.610]                   name <- changed[[kk]]
[01:28:10.610]                   NAME <- NAMES[[kk]]
[01:28:10.610]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.610]                     next
[01:28:10.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.610]                 }
[01:28:10.610]                 NAMES <- toupper(added)
[01:28:10.610]                 for (kk in seq_along(NAMES)) {
[01:28:10.610]                   name <- added[[kk]]
[01:28:10.610]                   NAME <- NAMES[[kk]]
[01:28:10.610]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.610]                     next
[01:28:10.610]                   args[[name]] <- ""
[01:28:10.610]                 }
[01:28:10.610]                 NAMES <- toupper(removed)
[01:28:10.610]                 for (kk in seq_along(NAMES)) {
[01:28:10.610]                   name <- removed[[kk]]
[01:28:10.610]                   NAME <- NAMES[[kk]]
[01:28:10.610]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.610]                     next
[01:28:10.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.610]                 }
[01:28:10.610]                 if (length(args) > 0) 
[01:28:10.610]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.610]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.610]             }
[01:28:10.610]             else {
[01:28:10.610]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.610]             }
[01:28:10.610]             {
[01:28:10.610]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.610]                   0L) {
[01:28:10.610]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.610]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.610]                   base::options(opts)
[01:28:10.610]                 }
[01:28:10.610]                 {
[01:28:10.610]                   {
[01:28:10.610]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.610]                     NULL
[01:28:10.610]                   }
[01:28:10.610]                   options(future.plan = NULL)
[01:28:10.610]                   if (is.na(NA_character_)) 
[01:28:10.610]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.610]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.610]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.610]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.610]                     envir = parent.frame()) 
[01:28:10.610]                   {
[01:28:10.610]                     if (is.function(workers)) 
[01:28:10.610]                       workers <- workers()
[01:28:10.610]                     workers <- structure(as.integer(workers), 
[01:28:10.610]                       class = class(workers))
[01:28:10.610]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.610]                       workers >= 1)
[01:28:10.610]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.610]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.610]                     }
[01:28:10.610]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.610]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.610]                       envir = envir)
[01:28:10.610]                     if (!future$lazy) 
[01:28:10.610]                       future <- run(future)
[01:28:10.610]                     invisible(future)
[01:28:10.610]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.610]                 }
[01:28:10.610]             }
[01:28:10.610]         }
[01:28:10.610]     })
[01:28:10.610]     if (TRUE) {
[01:28:10.610]         base::sink(type = "output", split = FALSE)
[01:28:10.610]         if (TRUE) {
[01:28:10.610]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.610]         }
[01:28:10.610]         else {
[01:28:10.610]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.610]         }
[01:28:10.610]         base::close(...future.stdout)
[01:28:10.610]         ...future.stdout <- NULL
[01:28:10.610]     }
[01:28:10.610]     ...future.result$conditions <- ...future.conditions
[01:28:10.610]     ...future.result$finished <- base::Sys.time()
[01:28:10.610]     ...future.result
[01:28:10.610] }
[01:28:10.615] Poll #1 (0): usedNodes() = 2, workers = 2
[01:28:10.636] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.636] - Validating connection of MultisessionFuture
[01:28:10.636] - received message: FutureResult
[01:28:10.636] - Received FutureResult
[01:28:10.637] - Erased future from FutureRegistry
[01:28:10.637] result() for ClusterFuture ...
[01:28:10.637] - result already collected: FutureResult
[01:28:10.637] result() for ClusterFuture ... done
[01:28:10.637] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.637] result() for ClusterFuture ...
[01:28:10.638] - result already collected: FutureResult
[01:28:10.638] result() for ClusterFuture ... done
[01:28:10.638] result() for ClusterFuture ...
[01:28:10.638] - result already collected: FutureResult
[01:28:10.638] result() for ClusterFuture ... done
[01:28:10.639] Exporting 2 global objects (112 bytes) to cluster node #2 ...
[01:28:10.639] Exporting 'a' (56 bytes) to cluster node #2 ...
[01:28:10.640] Exporting 'a' (56 bytes) to cluster node #2 ... DONE
[01:28:10.640] Exporting 'ii' (56 bytes) to cluster node #2 ...
[01:28:10.641] Exporting 'ii' (56 bytes) to cluster node #2 ... DONE
[01:28:10.641] Exporting 2 global objects (112 bytes) to cluster node #2 ... DONE
[01:28:10.641] MultisessionFuture started
[01:28:10.642] - Launch lazy future ... done
[01:28:10.642] run() for 'MultisessionFuture' ... done
[01:28:10.642] result() for ClusterFuture ...
[01:28:10.642] - result already collected: FutureResult
[01:28:10.642] result() for ClusterFuture ... done
[01:28:10.643] result() for ClusterFuture ...
[01:28:10.643] - result already collected: FutureResult
[01:28:10.643] result() for ClusterFuture ... done
[01:28:10.643] result() for ClusterFuture ...
[01:28:10.643] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.644] - Validating connection of MultisessionFuture
[01:28:10.644] - received message: FutureResult
[01:28:10.644] - Received FutureResult
[01:28:10.644] - Erased future from FutureRegistry
[01:28:10.644] result() for ClusterFuture ...
[01:28:10.645] - result already collected: FutureResult
[01:28:10.645] result() for ClusterFuture ... done
[01:28:10.645] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.645] result() for ClusterFuture ... done
[01:28:10.645] result() for ClusterFuture ...
[01:28:10.645] - result already collected: FutureResult
[01:28:10.646] result() for ClusterFuture ... done
[01:28:10.646] result() for ClusterFuture ...
[01:28:10.646] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.646] - Validating connection of MultisessionFuture
[01:28:10.659] - received message: FutureResult
[01:28:10.660] - Received FutureResult
[01:28:10.660] - Erased future from FutureRegistry
[01:28:10.660] result() for ClusterFuture ...
[01:28:10.660] - result already collected: FutureResult
[01:28:10.660] result() for ClusterFuture ... done
[01:28:10.660] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.661] result() for ClusterFuture ... done
[01:28:10.661] result() for ClusterFuture ...
[01:28:10.661] - result already collected: FutureResult
[01:28:10.661] result() for ClusterFuture ... done
[1] 1 2 3
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.662] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.662] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.665] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.665] Searching for globals ... DONE
[01:28:10.665] Resolving globals: TRUE
[01:28:10.665] Resolving any globals that are futures ...
[01:28:10.666] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.666] Resolving any globals that are futures ... DONE
[01:28:10.666] Resolving futures part of globals (recursively) ...
[01:28:10.667] resolve() on list ...
[01:28:10.667]  recursive: 99
[01:28:10.667]  length: 2
[01:28:10.667]  elements: 'a', 'ii'
[01:28:10.667]  length: 1 (resolved future 1)
[01:28:10.668]  length: 0 (resolved future 2)
[01:28:10.668] resolve() on list ... DONE
[01:28:10.668] - globals: [2] 'a', 'ii'
[01:28:10.668] Resolving futures part of globals (recursively) ... DONE
[01:28:10.668] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:10.669] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:10.669] - globals: [2] 'a', 'ii'
[01:28:10.669] 
[01:28:10.670] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.670] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.671] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.673] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.673] Searching for globals ... DONE
[01:28:10.674] Resolving globals: TRUE
[01:28:10.674] Resolving any globals that are futures ...
[01:28:10.674] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.674] Resolving any globals that are futures ... DONE
[01:28:10.675] Resolving futures part of globals (recursively) ...
[01:28:10.675] resolve() on list ...
[01:28:10.675]  recursive: 99
[01:28:10.675]  length: 2
[01:28:10.675]  elements: 'a', 'ii'
[01:28:10.676]  length: 1 (resolved future 1)
[01:28:10.676]  length: 0 (resolved future 2)
[01:28:10.676] resolve() on list ... DONE
[01:28:10.676] - globals: [2] 'a', 'ii'
[01:28:10.676] Resolving futures part of globals (recursively) ... DONE
[01:28:10.677] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:10.677] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:10.677] - globals: [2] 'a', 'ii'
[01:28:10.677] 
[01:28:10.678] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.678] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.679] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.681] - globals found: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.681] Searching for globals ... DONE
[01:28:10.682] Resolving globals: TRUE
[01:28:10.682] Resolving any globals that are futures ...
[01:28:10.682] - globals: [5] '{', '<-', '*', 'a', 'ii'
[01:28:10.682] Resolving any globals that are futures ... DONE
[01:28:10.683] Resolving futures part of globals (recursively) ...
[01:28:10.683] resolve() on list ...
[01:28:10.683]  recursive: 99
[01:28:10.683]  length: 2
[01:28:10.683]  elements: 'a', 'ii'
[01:28:10.684]  length: 1 (resolved future 1)
[01:28:10.684]  length: 0 (resolved future 2)
[01:28:10.684] resolve() on list ... DONE
[01:28:10.684] - globals: [2] 'a', 'ii'
[01:28:10.684] Resolving futures part of globals (recursively) ... DONE
[01:28:10.685] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:10.685] The total size of the 2 globals exported for future expression ('{; b <- a * ii; a <- 0; 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 'ii' (56 bytes of class 'numeric')
[01:28:10.685] - globals: [2] 'a', 'ii'
[01:28:10.685] 
[01:28:10.686] getGlobalsAndPackages() ... DONE
[01:28:10.686] run() for 'Future' ...
[01:28:10.686] - state: 'created'
[01:28:10.687] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.701] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.704] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.705]   - Field: 'node'
[01:28:10.705]   - Field: 'label'
[01:28:10.705]   - Field: 'local'
[01:28:10.705]   - Field: 'owner'
[01:28:10.706]   - Field: 'envir'
[01:28:10.706]   - Field: 'workers'
[01:28:10.706]   - Field: 'packages'
[01:28:10.706]   - Field: 'gc'
[01:28:10.706]   - Field: 'conditions'
[01:28:10.706]   - Field: 'persistent'
[01:28:10.707]   - Field: 'expr'
[01:28:10.707]   - Field: 'uuid'
[01:28:10.707]   - Field: 'seed'
[01:28:10.707]   - Field: 'version'
[01:28:10.707]   - Field: 'result'
[01:28:10.707]   - Field: 'asynchronous'
[01:28:10.708]   - Field: 'calls'
[01:28:10.708]   - Field: 'globals'
[01:28:10.708]   - Field: 'stdout'
[01:28:10.708]   - Field: 'earlySignal'
[01:28:10.709]   - Field: 'lazy'
[01:28:10.709]   - Field: 'state'
[01:28:10.709] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.709] - Launch lazy future ...
[01:28:10.710] Packages needed by the future expression (n = 0): <none>
[01:28:10.710] Packages needed by future strategies (n = 0): <none>
[01:28:10.710] {
[01:28:10.710]     {
[01:28:10.710]         {
[01:28:10.710]             ...future.startTime <- base::Sys.time()
[01:28:10.710]             {
[01:28:10.710]                 {
[01:28:10.710]                   {
[01:28:10.710]                     {
[01:28:10.710]                       base::local({
[01:28:10.710]                         has_future <- base::requireNamespace("future", 
[01:28:10.710]                           quietly = TRUE)
[01:28:10.710]                         if (has_future) {
[01:28:10.710]                           ns <- base::getNamespace("future")
[01:28:10.710]                           version <- ns[[".package"]][["version"]]
[01:28:10.710]                           if (is.null(version)) 
[01:28:10.710]                             version <- utils::packageVersion("future")
[01:28:10.710]                         }
[01:28:10.710]                         else {
[01:28:10.710]                           version <- NULL
[01:28:10.710]                         }
[01:28:10.710]                         if (!has_future || version < "1.8.0") {
[01:28:10.710]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.710]                             "", base::R.version$version.string), 
[01:28:10.710]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.710]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.710]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.710]                               "release", "version")], collapse = " "), 
[01:28:10.710]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.710]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.710]                             info)
[01:28:10.710]                           info <- base::paste(info, collapse = "; ")
[01:28:10.710]                           if (!has_future) {
[01:28:10.710]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.710]                               info)
[01:28:10.710]                           }
[01:28:10.710]                           else {
[01:28:10.710]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.710]                               info, version)
[01:28:10.710]                           }
[01:28:10.710]                           base::stop(msg)
[01:28:10.710]                         }
[01:28:10.710]                       })
[01:28:10.710]                     }
[01:28:10.710]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.710]                     base::options(mc.cores = 1L)
[01:28:10.710]                   }
[01:28:10.710]                   options(future.plan = NULL)
[01:28:10.710]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.710]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.710]                 }
[01:28:10.710]                 ...future.workdir <- getwd()
[01:28:10.710]             }
[01:28:10.710]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.710]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.710]         }
[01:28:10.710]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.710]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.710]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.710]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.710]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.710]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.710]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.710]             base::names(...future.oldOptions))
[01:28:10.710]     }
[01:28:10.710]     if (FALSE) {
[01:28:10.710]     }
[01:28:10.710]     else {
[01:28:10.710]         if (TRUE) {
[01:28:10.710]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.710]                 open = "w")
[01:28:10.710]         }
[01:28:10.710]         else {
[01:28:10.710]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.710]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.710]         }
[01:28:10.710]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.710]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.710]             base::sink(type = "output", split = FALSE)
[01:28:10.710]             base::close(...future.stdout)
[01:28:10.710]         }, add = TRUE)
[01:28:10.710]     }
[01:28:10.710]     ...future.frame <- base::sys.nframe()
[01:28:10.710]     ...future.conditions <- base::list()
[01:28:10.710]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.710]     if (FALSE) {
[01:28:10.710]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.710]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.710]     }
[01:28:10.710]     ...future.result <- base::tryCatch({
[01:28:10.710]         base::withCallingHandlers({
[01:28:10.710]             ...future.value <- base::withVisible(base::local({
[01:28:10.710]                 ...future.makeSendCondition <- base::local({
[01:28:10.710]                   sendCondition <- NULL
[01:28:10.710]                   function(frame = 1L) {
[01:28:10.710]                     if (is.function(sendCondition)) 
[01:28:10.710]                       return(sendCondition)
[01:28:10.710]                     ns <- getNamespace("parallel")
[01:28:10.710]                     if (exists("sendData", mode = "function", 
[01:28:10.710]                       envir = ns)) {
[01:28:10.710]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.710]                         envir = ns)
[01:28:10.710]                       envir <- sys.frame(frame)
[01:28:10.710]                       master <- NULL
[01:28:10.710]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.710]                         !identical(envir, emptyenv())) {
[01:28:10.710]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.710]                           inherits = FALSE)) {
[01:28:10.710]                           master <- get("master", mode = "list", 
[01:28:10.710]                             envir = envir, inherits = FALSE)
[01:28:10.710]                           if (inherits(master, c("SOCKnode", 
[01:28:10.710]                             "SOCK0node"))) {
[01:28:10.710]                             sendCondition <<- function(cond) {
[01:28:10.710]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.710]                                 success = TRUE)
[01:28:10.710]                               parallel_sendData(master, data)
[01:28:10.710]                             }
[01:28:10.710]                             return(sendCondition)
[01:28:10.710]                           }
[01:28:10.710]                         }
[01:28:10.710]                         frame <- frame + 1L
[01:28:10.710]                         envir <- sys.frame(frame)
[01:28:10.710]                       }
[01:28:10.710]                     }
[01:28:10.710]                     sendCondition <<- function(cond) NULL
[01:28:10.710]                   }
[01:28:10.710]                 })
[01:28:10.710]                 withCallingHandlers({
[01:28:10.710]                   {
[01:28:10.710]                     b <- a * ii
[01:28:10.710]                     a <- 0
[01:28:10.710]                     b
[01:28:10.710]                   }
[01:28:10.710]                 }, immediateCondition = function(cond) {
[01:28:10.710]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.710]                   sendCondition(cond)
[01:28:10.710]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.710]                   {
[01:28:10.710]                     inherits <- base::inherits
[01:28:10.710]                     invokeRestart <- base::invokeRestart
[01:28:10.710]                     is.null <- base::is.null
[01:28:10.710]                     muffled <- FALSE
[01:28:10.710]                     if (inherits(cond, "message")) {
[01:28:10.710]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.710]                       if (muffled) 
[01:28:10.710]                         invokeRestart("muffleMessage")
[01:28:10.710]                     }
[01:28:10.710]                     else if (inherits(cond, "warning")) {
[01:28:10.710]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.710]                       if (muffled) 
[01:28:10.710]                         invokeRestart("muffleWarning")
[01:28:10.710]                     }
[01:28:10.710]                     else if (inherits(cond, "condition")) {
[01:28:10.710]                       if (!is.null(pattern)) {
[01:28:10.710]                         computeRestarts <- base::computeRestarts
[01:28:10.710]                         grepl <- base::grepl
[01:28:10.710]                         restarts <- computeRestarts(cond)
[01:28:10.710]                         for (restart in restarts) {
[01:28:10.710]                           name <- restart$name
[01:28:10.710]                           if (is.null(name)) 
[01:28:10.710]                             next
[01:28:10.710]                           if (!grepl(pattern, name)) 
[01:28:10.710]                             next
[01:28:10.710]                           invokeRestart(restart)
[01:28:10.710]                           muffled <- TRUE
[01:28:10.710]                           break
[01:28:10.710]                         }
[01:28:10.710]                       }
[01:28:10.710]                     }
[01:28:10.710]                     invisible(muffled)
[01:28:10.710]                   }
[01:28:10.710]                   muffleCondition(cond)
[01:28:10.710]                 })
[01:28:10.710]             }))
[01:28:10.710]             future::FutureResult(value = ...future.value$value, 
[01:28:10.710]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.710]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.710]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.710]                     ...future.globalenv.names))
[01:28:10.710]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.710]         }, condition = base::local({
[01:28:10.710]             c <- base::c
[01:28:10.710]             inherits <- base::inherits
[01:28:10.710]             invokeRestart <- base::invokeRestart
[01:28:10.710]             length <- base::length
[01:28:10.710]             list <- base::list
[01:28:10.710]             seq.int <- base::seq.int
[01:28:10.710]             signalCondition <- base::signalCondition
[01:28:10.710]             sys.calls <- base::sys.calls
[01:28:10.710]             `[[` <- base::`[[`
[01:28:10.710]             `+` <- base::`+`
[01:28:10.710]             `<<-` <- base::`<<-`
[01:28:10.710]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.710]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.710]                   3L)]
[01:28:10.710]             }
[01:28:10.710]             function(cond) {
[01:28:10.710]                 is_error <- inherits(cond, "error")
[01:28:10.710]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.710]                   NULL)
[01:28:10.710]                 if (is_error) {
[01:28:10.710]                   sessionInformation <- function() {
[01:28:10.710]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.710]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.710]                       search = base::search(), system = base::Sys.info())
[01:28:10.710]                   }
[01:28:10.710]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.710]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.710]                     cond$call), session = sessionInformation(), 
[01:28:10.710]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.710]                   signalCondition(cond)
[01:28:10.710]                 }
[01:28:10.710]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.710]                 "immediateCondition"))) {
[01:28:10.710]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.710]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.710]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.710]                   if (TRUE && !signal) {
[01:28:10.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.710]                     {
[01:28:10.710]                       inherits <- base::inherits
[01:28:10.710]                       invokeRestart <- base::invokeRestart
[01:28:10.710]                       is.null <- base::is.null
[01:28:10.710]                       muffled <- FALSE
[01:28:10.710]                       if (inherits(cond, "message")) {
[01:28:10.710]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.710]                         if (muffled) 
[01:28:10.710]                           invokeRestart("muffleMessage")
[01:28:10.710]                       }
[01:28:10.710]                       else if (inherits(cond, "warning")) {
[01:28:10.710]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.710]                         if (muffled) 
[01:28:10.710]                           invokeRestart("muffleWarning")
[01:28:10.710]                       }
[01:28:10.710]                       else if (inherits(cond, "condition")) {
[01:28:10.710]                         if (!is.null(pattern)) {
[01:28:10.710]                           computeRestarts <- base::computeRestarts
[01:28:10.710]                           grepl <- base::grepl
[01:28:10.710]                           restarts <- computeRestarts(cond)
[01:28:10.710]                           for (restart in restarts) {
[01:28:10.710]                             name <- restart$name
[01:28:10.710]                             if (is.null(name)) 
[01:28:10.710]                               next
[01:28:10.710]                             if (!grepl(pattern, name)) 
[01:28:10.710]                               next
[01:28:10.710]                             invokeRestart(restart)
[01:28:10.710]                             muffled <- TRUE
[01:28:10.710]                             break
[01:28:10.710]                           }
[01:28:10.710]                         }
[01:28:10.710]                       }
[01:28:10.710]                       invisible(muffled)
[01:28:10.710]                     }
[01:28:10.710]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.710]                   }
[01:28:10.710]                 }
[01:28:10.710]                 else {
[01:28:10.710]                   if (TRUE) {
[01:28:10.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.710]                     {
[01:28:10.710]                       inherits <- base::inherits
[01:28:10.710]                       invokeRestart <- base::invokeRestart
[01:28:10.710]                       is.null <- base::is.null
[01:28:10.710]                       muffled <- FALSE
[01:28:10.710]                       if (inherits(cond, "message")) {
[01:28:10.710]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.710]                         if (muffled) 
[01:28:10.710]                           invokeRestart("muffleMessage")
[01:28:10.710]                       }
[01:28:10.710]                       else if (inherits(cond, "warning")) {
[01:28:10.710]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.710]                         if (muffled) 
[01:28:10.710]                           invokeRestart("muffleWarning")
[01:28:10.710]                       }
[01:28:10.710]                       else if (inherits(cond, "condition")) {
[01:28:10.710]                         if (!is.null(pattern)) {
[01:28:10.710]                           computeRestarts <- base::computeRestarts
[01:28:10.710]                           grepl <- base::grepl
[01:28:10.710]                           restarts <- computeRestarts(cond)
[01:28:10.710]                           for (restart in restarts) {
[01:28:10.710]                             name <- restart$name
[01:28:10.710]                             if (is.null(name)) 
[01:28:10.710]                               next
[01:28:10.710]                             if (!grepl(pattern, name)) 
[01:28:10.710]                               next
[01:28:10.710]                             invokeRestart(restart)
[01:28:10.710]                             muffled <- TRUE
[01:28:10.710]                             break
[01:28:10.710]                           }
[01:28:10.710]                         }
[01:28:10.710]                       }
[01:28:10.710]                       invisible(muffled)
[01:28:10.710]                     }
[01:28:10.710]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.710]                   }
[01:28:10.710]                 }
[01:28:10.710]             }
[01:28:10.710]         }))
[01:28:10.710]     }, error = function(ex) {
[01:28:10.710]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.710]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.710]                 ...future.rng), started = ...future.startTime, 
[01:28:10.710]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.710]             version = "1.8"), class = "FutureResult")
[01:28:10.710]     }, finally = {
[01:28:10.710]         if (!identical(...future.workdir, getwd())) 
[01:28:10.710]             setwd(...future.workdir)
[01:28:10.710]         {
[01:28:10.710]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.710]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.710]             }
[01:28:10.710]             base::options(...future.oldOptions)
[01:28:10.710]             if (.Platform$OS.type == "windows") {
[01:28:10.710]                 old_names <- names(...future.oldEnvVars)
[01:28:10.710]                 envs <- base::Sys.getenv()
[01:28:10.710]                 names <- names(envs)
[01:28:10.710]                 common <- intersect(names, old_names)
[01:28:10.710]                 added <- setdiff(names, old_names)
[01:28:10.710]                 removed <- setdiff(old_names, names)
[01:28:10.710]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.710]                   envs[common]]
[01:28:10.710]                 NAMES <- toupper(changed)
[01:28:10.710]                 args <- list()
[01:28:10.710]                 for (kk in seq_along(NAMES)) {
[01:28:10.710]                   name <- changed[[kk]]
[01:28:10.710]                   NAME <- NAMES[[kk]]
[01:28:10.710]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.710]                     next
[01:28:10.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.710]                 }
[01:28:10.710]                 NAMES <- toupper(added)
[01:28:10.710]                 for (kk in seq_along(NAMES)) {
[01:28:10.710]                   name <- added[[kk]]
[01:28:10.710]                   NAME <- NAMES[[kk]]
[01:28:10.710]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.710]                     next
[01:28:10.710]                   args[[name]] <- ""
[01:28:10.710]                 }
[01:28:10.710]                 NAMES <- toupper(removed)
[01:28:10.710]                 for (kk in seq_along(NAMES)) {
[01:28:10.710]                   name <- removed[[kk]]
[01:28:10.710]                   NAME <- NAMES[[kk]]
[01:28:10.710]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.710]                     next
[01:28:10.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.710]                 }
[01:28:10.710]                 if (length(args) > 0) 
[01:28:10.710]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.710]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.710]             }
[01:28:10.710]             else {
[01:28:10.710]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.710]             }
[01:28:10.710]             {
[01:28:10.710]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.710]                   0L) {
[01:28:10.710]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.710]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.710]                   base::options(opts)
[01:28:10.710]                 }
[01:28:10.710]                 {
[01:28:10.710]                   {
[01:28:10.710]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.710]                     NULL
[01:28:10.710]                   }
[01:28:10.710]                   options(future.plan = NULL)
[01:28:10.710]                   if (is.na(NA_character_)) 
[01:28:10.710]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.710]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.710]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.710]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.710]                     envir = parent.frame()) 
[01:28:10.710]                   {
[01:28:10.710]                     if (is.function(workers)) 
[01:28:10.710]                       workers <- workers()
[01:28:10.710]                     workers <- structure(as.integer(workers), 
[01:28:10.710]                       class = class(workers))
[01:28:10.710]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.710]                       workers >= 1)
[01:28:10.710]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.710]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.710]                     }
[01:28:10.710]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.710]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.710]                       envir = envir)
[01:28:10.710]                     if (!future$lazy) 
[01:28:10.710]                       future <- run(future)
[01:28:10.710]                     invisible(future)
[01:28:10.710]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.710]                 }
[01:28:10.710]             }
[01:28:10.710]         }
[01:28:10.710]     })
[01:28:10.710]     if (TRUE) {
[01:28:10.710]         base::sink(type = "output", split = FALSE)
[01:28:10.710]         if (TRUE) {
[01:28:10.710]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.710]         }
[01:28:10.710]         else {
[01:28:10.710]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.710]         }
[01:28:10.710]         base::close(...future.stdout)
[01:28:10.710]         ...future.stdout <- NULL
[01:28:10.710]     }
[01:28:10.710]     ...future.result$conditions <- ...future.conditions
[01:28:10.710]     ...future.result$finished <- base::Sys.time()
[01:28:10.710]     ...future.result
[01:28:10.710] }
[01:28:10.716] Exporting 2 global objects (112 bytes) to cluster node #1 ...
[01:28:10.716] Exporting 'a' (56 bytes) to cluster node #1 ...
[01:28:10.718] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[01:28:10.718] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:10.719] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:10.719] Exporting 2 global objects (112 bytes) to cluster node #1 ... DONE
[01:28:10.720] MultisessionFuture started
[01:28:10.720] - Launch lazy future ... done
[01:28:10.720] run() for 'MultisessionFuture' ... done
[01:28:10.720] result() for ClusterFuture ...
[01:28:10.720] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.720] - Validating connection of MultisessionFuture
[01:28:10.736] - received message: FutureResult
[01:28:10.737] - Received FutureResult
[01:28:10.737] - Erased future from FutureRegistry
[01:28:10.737] result() for ClusterFuture ...
[01:28:10.737] - result already collected: FutureResult
[01:28:10.737] result() for ClusterFuture ... done
[01:28:10.738] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.738] result() for ClusterFuture ... done
[01:28:10.738] result() for ClusterFuture ...
[01:28:10.738] - result already collected: FutureResult
[01:28:10.738] result() for ClusterFuture ... done
[01:28:10.738] run() for 'Future' ...
[01:28:10.739] - state: 'created'
[01:28:10.739] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.753] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.753] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.754]   - Field: 'node'
[01:28:10.754]   - Field: 'label'
[01:28:10.754]   - Field: 'local'
[01:28:10.754]   - Field: 'owner'
[01:28:10.754]   - Field: 'envir'
[01:28:10.754]   - Field: 'workers'
[01:28:10.755]   - Field: 'packages'
[01:28:10.755]   - Field: 'gc'
[01:28:10.755]   - Field: 'conditions'
[01:28:10.755]   - Field: 'persistent'
[01:28:10.755]   - Field: 'expr'
[01:28:10.756]   - Field: 'uuid'
[01:28:10.756]   - Field: 'seed'
[01:28:10.756]   - Field: 'version'
[01:28:10.756]   - Field: 'result'
[01:28:10.756]   - Field: 'asynchronous'
[01:28:10.756]   - Field: 'calls'
[01:28:10.757]   - Field: 'globals'
[01:28:10.757]   - Field: 'stdout'
[01:28:10.757]   - Field: 'earlySignal'
[01:28:10.757]   - Field: 'lazy'
[01:28:10.757]   - Field: 'state'
[01:28:10.757] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.758] - Launch lazy future ...
[01:28:10.758] Packages needed by the future expression (n = 0): <none>
[01:28:10.758] Packages needed by future strategies (n = 0): <none>
[01:28:10.759] {
[01:28:10.759]     {
[01:28:10.759]         {
[01:28:10.759]             ...future.startTime <- base::Sys.time()
[01:28:10.759]             {
[01:28:10.759]                 {
[01:28:10.759]                   {
[01:28:10.759]                     {
[01:28:10.759]                       base::local({
[01:28:10.759]                         has_future <- base::requireNamespace("future", 
[01:28:10.759]                           quietly = TRUE)
[01:28:10.759]                         if (has_future) {
[01:28:10.759]                           ns <- base::getNamespace("future")
[01:28:10.759]                           version <- ns[[".package"]][["version"]]
[01:28:10.759]                           if (is.null(version)) 
[01:28:10.759]                             version <- utils::packageVersion("future")
[01:28:10.759]                         }
[01:28:10.759]                         else {
[01:28:10.759]                           version <- NULL
[01:28:10.759]                         }
[01:28:10.759]                         if (!has_future || version < "1.8.0") {
[01:28:10.759]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.759]                             "", base::R.version$version.string), 
[01:28:10.759]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.759]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.759]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.759]                               "release", "version")], collapse = " "), 
[01:28:10.759]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.759]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.759]                             info)
[01:28:10.759]                           info <- base::paste(info, collapse = "; ")
[01:28:10.759]                           if (!has_future) {
[01:28:10.759]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.759]                               info)
[01:28:10.759]                           }
[01:28:10.759]                           else {
[01:28:10.759]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.759]                               info, version)
[01:28:10.759]                           }
[01:28:10.759]                           base::stop(msg)
[01:28:10.759]                         }
[01:28:10.759]                       })
[01:28:10.759]                     }
[01:28:10.759]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.759]                     base::options(mc.cores = 1L)
[01:28:10.759]                   }
[01:28:10.759]                   options(future.plan = NULL)
[01:28:10.759]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.759]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.759]                 }
[01:28:10.759]                 ...future.workdir <- getwd()
[01:28:10.759]             }
[01:28:10.759]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.759]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.759]         }
[01:28:10.759]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.759]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.759]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.759]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.759]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.759]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.759]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.759]             base::names(...future.oldOptions))
[01:28:10.759]     }
[01:28:10.759]     if (FALSE) {
[01:28:10.759]     }
[01:28:10.759]     else {
[01:28:10.759]         if (TRUE) {
[01:28:10.759]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.759]                 open = "w")
[01:28:10.759]         }
[01:28:10.759]         else {
[01:28:10.759]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.759]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.759]         }
[01:28:10.759]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.759]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.759]             base::sink(type = "output", split = FALSE)
[01:28:10.759]             base::close(...future.stdout)
[01:28:10.759]         }, add = TRUE)
[01:28:10.759]     }
[01:28:10.759]     ...future.frame <- base::sys.nframe()
[01:28:10.759]     ...future.conditions <- base::list()
[01:28:10.759]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.759]     if (FALSE) {
[01:28:10.759]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.759]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.759]     }
[01:28:10.759]     ...future.result <- base::tryCatch({
[01:28:10.759]         base::withCallingHandlers({
[01:28:10.759]             ...future.value <- base::withVisible(base::local({
[01:28:10.759]                 ...future.makeSendCondition <- base::local({
[01:28:10.759]                   sendCondition <- NULL
[01:28:10.759]                   function(frame = 1L) {
[01:28:10.759]                     if (is.function(sendCondition)) 
[01:28:10.759]                       return(sendCondition)
[01:28:10.759]                     ns <- getNamespace("parallel")
[01:28:10.759]                     if (exists("sendData", mode = "function", 
[01:28:10.759]                       envir = ns)) {
[01:28:10.759]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.759]                         envir = ns)
[01:28:10.759]                       envir <- sys.frame(frame)
[01:28:10.759]                       master <- NULL
[01:28:10.759]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.759]                         !identical(envir, emptyenv())) {
[01:28:10.759]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.759]                           inherits = FALSE)) {
[01:28:10.759]                           master <- get("master", mode = "list", 
[01:28:10.759]                             envir = envir, inherits = FALSE)
[01:28:10.759]                           if (inherits(master, c("SOCKnode", 
[01:28:10.759]                             "SOCK0node"))) {
[01:28:10.759]                             sendCondition <<- function(cond) {
[01:28:10.759]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.759]                                 success = TRUE)
[01:28:10.759]                               parallel_sendData(master, data)
[01:28:10.759]                             }
[01:28:10.759]                             return(sendCondition)
[01:28:10.759]                           }
[01:28:10.759]                         }
[01:28:10.759]                         frame <- frame + 1L
[01:28:10.759]                         envir <- sys.frame(frame)
[01:28:10.759]                       }
[01:28:10.759]                     }
[01:28:10.759]                     sendCondition <<- function(cond) NULL
[01:28:10.759]                   }
[01:28:10.759]                 })
[01:28:10.759]                 withCallingHandlers({
[01:28:10.759]                   {
[01:28:10.759]                     b <- a * ii
[01:28:10.759]                     a <- 0
[01:28:10.759]                     b
[01:28:10.759]                   }
[01:28:10.759]                 }, immediateCondition = function(cond) {
[01:28:10.759]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.759]                   sendCondition(cond)
[01:28:10.759]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.759]                   {
[01:28:10.759]                     inherits <- base::inherits
[01:28:10.759]                     invokeRestart <- base::invokeRestart
[01:28:10.759]                     is.null <- base::is.null
[01:28:10.759]                     muffled <- FALSE
[01:28:10.759]                     if (inherits(cond, "message")) {
[01:28:10.759]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.759]                       if (muffled) 
[01:28:10.759]                         invokeRestart("muffleMessage")
[01:28:10.759]                     }
[01:28:10.759]                     else if (inherits(cond, "warning")) {
[01:28:10.759]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.759]                       if (muffled) 
[01:28:10.759]                         invokeRestart("muffleWarning")
[01:28:10.759]                     }
[01:28:10.759]                     else if (inherits(cond, "condition")) {
[01:28:10.759]                       if (!is.null(pattern)) {
[01:28:10.759]                         computeRestarts <- base::computeRestarts
[01:28:10.759]                         grepl <- base::grepl
[01:28:10.759]                         restarts <- computeRestarts(cond)
[01:28:10.759]                         for (restart in restarts) {
[01:28:10.759]                           name <- restart$name
[01:28:10.759]                           if (is.null(name)) 
[01:28:10.759]                             next
[01:28:10.759]                           if (!grepl(pattern, name)) 
[01:28:10.759]                             next
[01:28:10.759]                           invokeRestart(restart)
[01:28:10.759]                           muffled <- TRUE
[01:28:10.759]                           break
[01:28:10.759]                         }
[01:28:10.759]                       }
[01:28:10.759]                     }
[01:28:10.759]                     invisible(muffled)
[01:28:10.759]                   }
[01:28:10.759]                   muffleCondition(cond)
[01:28:10.759]                 })
[01:28:10.759]             }))
[01:28:10.759]             future::FutureResult(value = ...future.value$value, 
[01:28:10.759]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.759]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.759]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.759]                     ...future.globalenv.names))
[01:28:10.759]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.759]         }, condition = base::local({
[01:28:10.759]             c <- base::c
[01:28:10.759]             inherits <- base::inherits
[01:28:10.759]             invokeRestart <- base::invokeRestart
[01:28:10.759]             length <- base::length
[01:28:10.759]             list <- base::list
[01:28:10.759]             seq.int <- base::seq.int
[01:28:10.759]             signalCondition <- base::signalCondition
[01:28:10.759]             sys.calls <- base::sys.calls
[01:28:10.759]             `[[` <- base::`[[`
[01:28:10.759]             `+` <- base::`+`
[01:28:10.759]             `<<-` <- base::`<<-`
[01:28:10.759]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.759]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.759]                   3L)]
[01:28:10.759]             }
[01:28:10.759]             function(cond) {
[01:28:10.759]                 is_error <- inherits(cond, "error")
[01:28:10.759]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.759]                   NULL)
[01:28:10.759]                 if (is_error) {
[01:28:10.759]                   sessionInformation <- function() {
[01:28:10.759]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.759]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.759]                       search = base::search(), system = base::Sys.info())
[01:28:10.759]                   }
[01:28:10.759]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.759]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.759]                     cond$call), session = sessionInformation(), 
[01:28:10.759]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.759]                   signalCondition(cond)
[01:28:10.759]                 }
[01:28:10.759]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.759]                 "immediateCondition"))) {
[01:28:10.759]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.759]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.759]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.759]                   if (TRUE && !signal) {
[01:28:10.759]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.759]                     {
[01:28:10.759]                       inherits <- base::inherits
[01:28:10.759]                       invokeRestart <- base::invokeRestart
[01:28:10.759]                       is.null <- base::is.null
[01:28:10.759]                       muffled <- FALSE
[01:28:10.759]                       if (inherits(cond, "message")) {
[01:28:10.759]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.759]                         if (muffled) 
[01:28:10.759]                           invokeRestart("muffleMessage")
[01:28:10.759]                       }
[01:28:10.759]                       else if (inherits(cond, "warning")) {
[01:28:10.759]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.759]                         if (muffled) 
[01:28:10.759]                           invokeRestart("muffleWarning")
[01:28:10.759]                       }
[01:28:10.759]                       else if (inherits(cond, "condition")) {
[01:28:10.759]                         if (!is.null(pattern)) {
[01:28:10.759]                           computeRestarts <- base::computeRestarts
[01:28:10.759]                           grepl <- base::grepl
[01:28:10.759]                           restarts <- computeRestarts(cond)
[01:28:10.759]                           for (restart in restarts) {
[01:28:10.759]                             name <- restart$name
[01:28:10.759]                             if (is.null(name)) 
[01:28:10.759]                               next
[01:28:10.759]                             if (!grepl(pattern, name)) 
[01:28:10.759]                               next
[01:28:10.759]                             invokeRestart(restart)
[01:28:10.759]                             muffled <- TRUE
[01:28:10.759]                             break
[01:28:10.759]                           }
[01:28:10.759]                         }
[01:28:10.759]                       }
[01:28:10.759]                       invisible(muffled)
[01:28:10.759]                     }
[01:28:10.759]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.759]                   }
[01:28:10.759]                 }
[01:28:10.759]                 else {
[01:28:10.759]                   if (TRUE) {
[01:28:10.759]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.759]                     {
[01:28:10.759]                       inherits <- base::inherits
[01:28:10.759]                       invokeRestart <- base::invokeRestart
[01:28:10.759]                       is.null <- base::is.null
[01:28:10.759]                       muffled <- FALSE
[01:28:10.759]                       if (inherits(cond, "message")) {
[01:28:10.759]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.759]                         if (muffled) 
[01:28:10.759]                           invokeRestart("muffleMessage")
[01:28:10.759]                       }
[01:28:10.759]                       else if (inherits(cond, "warning")) {
[01:28:10.759]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.759]                         if (muffled) 
[01:28:10.759]                           invokeRestart("muffleWarning")
[01:28:10.759]                       }
[01:28:10.759]                       else if (inherits(cond, "condition")) {
[01:28:10.759]                         if (!is.null(pattern)) {
[01:28:10.759]                           computeRestarts <- base::computeRestarts
[01:28:10.759]                           grepl <- base::grepl
[01:28:10.759]                           restarts <- computeRestarts(cond)
[01:28:10.759]                           for (restart in restarts) {
[01:28:10.759]                             name <- restart$name
[01:28:10.759]                             if (is.null(name)) 
[01:28:10.759]                               next
[01:28:10.759]                             if (!grepl(pattern, name)) 
[01:28:10.759]                               next
[01:28:10.759]                             invokeRestart(restart)
[01:28:10.759]                             muffled <- TRUE
[01:28:10.759]                             break
[01:28:10.759]                           }
[01:28:10.759]                         }
[01:28:10.759]                       }
[01:28:10.759]                       invisible(muffled)
[01:28:10.759]                     }
[01:28:10.759]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.759]                   }
[01:28:10.759]                 }
[01:28:10.759]             }
[01:28:10.759]         }))
[01:28:10.759]     }, error = function(ex) {
[01:28:10.759]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.759]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.759]                 ...future.rng), started = ...future.startTime, 
[01:28:10.759]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.759]             version = "1.8"), class = "FutureResult")
[01:28:10.759]     }, finally = {
[01:28:10.759]         if (!identical(...future.workdir, getwd())) 
[01:28:10.759]             setwd(...future.workdir)
[01:28:10.759]         {
[01:28:10.759]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.759]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.759]             }
[01:28:10.759]             base::options(...future.oldOptions)
[01:28:10.759]             if (.Platform$OS.type == "windows") {
[01:28:10.759]                 old_names <- names(...future.oldEnvVars)
[01:28:10.759]                 envs <- base::Sys.getenv()
[01:28:10.759]                 names <- names(envs)
[01:28:10.759]                 common <- intersect(names, old_names)
[01:28:10.759]                 added <- setdiff(names, old_names)
[01:28:10.759]                 removed <- setdiff(old_names, names)
[01:28:10.759]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.759]                   envs[common]]
[01:28:10.759]                 NAMES <- toupper(changed)
[01:28:10.759]                 args <- list()
[01:28:10.759]                 for (kk in seq_along(NAMES)) {
[01:28:10.759]                   name <- changed[[kk]]
[01:28:10.759]                   NAME <- NAMES[[kk]]
[01:28:10.759]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.759]                     next
[01:28:10.759]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.759]                 }
[01:28:10.759]                 NAMES <- toupper(added)
[01:28:10.759]                 for (kk in seq_along(NAMES)) {
[01:28:10.759]                   name <- added[[kk]]
[01:28:10.759]                   NAME <- NAMES[[kk]]
[01:28:10.759]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.759]                     next
[01:28:10.759]                   args[[name]] <- ""
[01:28:10.759]                 }
[01:28:10.759]                 NAMES <- toupper(removed)
[01:28:10.759]                 for (kk in seq_along(NAMES)) {
[01:28:10.759]                   name <- removed[[kk]]
[01:28:10.759]                   NAME <- NAMES[[kk]]
[01:28:10.759]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.759]                     next
[01:28:10.759]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.759]                 }
[01:28:10.759]                 if (length(args) > 0) 
[01:28:10.759]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.759]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.759]             }
[01:28:10.759]             else {
[01:28:10.759]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.759]             }
[01:28:10.759]             {
[01:28:10.759]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.759]                   0L) {
[01:28:10.759]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.759]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.759]                   base::options(opts)
[01:28:10.759]                 }
[01:28:10.759]                 {
[01:28:10.759]                   {
[01:28:10.759]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.759]                     NULL
[01:28:10.759]                   }
[01:28:10.759]                   options(future.plan = NULL)
[01:28:10.759]                   if (is.na(NA_character_)) 
[01:28:10.759]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.759]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.759]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.759]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.759]                     envir = parent.frame()) 
[01:28:10.759]                   {
[01:28:10.759]                     if (is.function(workers)) 
[01:28:10.759]                       workers <- workers()
[01:28:10.759]                     workers <- structure(as.integer(workers), 
[01:28:10.759]                       class = class(workers))
[01:28:10.759]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.759]                       workers >= 1)
[01:28:10.759]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.759]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.759]                     }
[01:28:10.759]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.759]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.759]                       envir = envir)
[01:28:10.759]                     if (!future$lazy) 
[01:28:10.759]                       future <- run(future)
[01:28:10.759]                     invisible(future)
[01:28:10.759]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.759]                 }
[01:28:10.759]             }
[01:28:10.759]         }
[01:28:10.759]     })
[01:28:10.759]     if (TRUE) {
[01:28:10.759]         base::sink(type = "output", split = FALSE)
[01:28:10.759]         if (TRUE) {
[01:28:10.759]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.759]         }
[01:28:10.759]         else {
[01:28:10.759]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.759]         }
[01:28:10.759]         base::close(...future.stdout)
[01:28:10.759]         ...future.stdout <- NULL
[01:28:10.759]     }
[01:28:10.759]     ...future.result$conditions <- ...future.conditions
[01:28:10.759]     ...future.result$finished <- base::Sys.time()
[01:28:10.759]     ...future.result
[01:28:10.759] }
[01:28:10.764] Exporting 2 global objects (112 bytes) to cluster node #1 ...
[01:28:10.765] Exporting 'a' (56 bytes) to cluster node #1 ...
[01:28:10.765] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[01:28:10.765] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:10.766] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:10.766] Exporting 2 global objects (112 bytes) to cluster node #1 ... DONE
[01:28:10.767] MultisessionFuture started
[01:28:10.767] - Launch lazy future ... done
[01:28:10.767] run() for 'MultisessionFuture' ... done
[01:28:10.767] result() for ClusterFuture ...
[01:28:10.767] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.767] - Validating connection of MultisessionFuture
[01:28:10.784] - received message: FutureResult
[01:28:10.785] - Received FutureResult
[01:28:10.785] - Erased future from FutureRegistry
[01:28:10.785] result() for ClusterFuture ...
[01:28:10.785] - result already collected: FutureResult
[01:28:10.785] result() for ClusterFuture ... done
[01:28:10.786] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.786] result() for ClusterFuture ... done
[01:28:10.786] result() for ClusterFuture ...
[01:28:10.786] - result already collected: FutureResult
[01:28:10.786] result() for ClusterFuture ... done
[01:28:10.786] run() for 'Future' ...
[01:28:10.787] - state: 'created'
[01:28:10.787] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.801] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.802] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.802]   - Field: 'node'
[01:28:10.802]   - Field: 'label'
[01:28:10.802]   - Field: 'local'
[01:28:10.803]   - Field: 'owner'
[01:28:10.803]   - Field: 'envir'
[01:28:10.803]   - Field: 'workers'
[01:28:10.803]   - Field: 'packages'
[01:28:10.803]   - Field: 'gc'
[01:28:10.803]   - Field: 'conditions'
[01:28:10.804]   - Field: 'persistent'
[01:28:10.804]   - Field: 'expr'
[01:28:10.804]   - Field: 'uuid'
[01:28:10.804]   - Field: 'seed'
[01:28:10.804]   - Field: 'version'
[01:28:10.804]   - Field: 'result'
[01:28:10.805]   - Field: 'asynchronous'
[01:28:10.805]   - Field: 'calls'
[01:28:10.805]   - Field: 'globals'
[01:28:10.805]   - Field: 'stdout'
[01:28:10.805]   - Field: 'earlySignal'
[01:28:10.806]   - Field: 'lazy'
[01:28:10.806]   - Field: 'state'
[01:28:10.806] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.806] - Launch lazy future ...
[01:28:10.806] Packages needed by the future expression (n = 0): <none>
[01:28:10.807] Packages needed by future strategies (n = 0): <none>
[01:28:10.807] {
[01:28:10.807]     {
[01:28:10.807]         {
[01:28:10.807]             ...future.startTime <- base::Sys.time()
[01:28:10.807]             {
[01:28:10.807]                 {
[01:28:10.807]                   {
[01:28:10.807]                     {
[01:28:10.807]                       base::local({
[01:28:10.807]                         has_future <- base::requireNamespace("future", 
[01:28:10.807]                           quietly = TRUE)
[01:28:10.807]                         if (has_future) {
[01:28:10.807]                           ns <- base::getNamespace("future")
[01:28:10.807]                           version <- ns[[".package"]][["version"]]
[01:28:10.807]                           if (is.null(version)) 
[01:28:10.807]                             version <- utils::packageVersion("future")
[01:28:10.807]                         }
[01:28:10.807]                         else {
[01:28:10.807]                           version <- NULL
[01:28:10.807]                         }
[01:28:10.807]                         if (!has_future || version < "1.8.0") {
[01:28:10.807]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.807]                             "", base::R.version$version.string), 
[01:28:10.807]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.807]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.807]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.807]                               "release", "version")], collapse = " "), 
[01:28:10.807]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.807]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.807]                             info)
[01:28:10.807]                           info <- base::paste(info, collapse = "; ")
[01:28:10.807]                           if (!has_future) {
[01:28:10.807]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.807]                               info)
[01:28:10.807]                           }
[01:28:10.807]                           else {
[01:28:10.807]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.807]                               info, version)
[01:28:10.807]                           }
[01:28:10.807]                           base::stop(msg)
[01:28:10.807]                         }
[01:28:10.807]                       })
[01:28:10.807]                     }
[01:28:10.807]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.807]                     base::options(mc.cores = 1L)
[01:28:10.807]                   }
[01:28:10.807]                   options(future.plan = NULL)
[01:28:10.807]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.807]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.807]                 }
[01:28:10.807]                 ...future.workdir <- getwd()
[01:28:10.807]             }
[01:28:10.807]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.807]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.807]         }
[01:28:10.807]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.807]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.807]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.807]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.807]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.807]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.807]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.807]             base::names(...future.oldOptions))
[01:28:10.807]     }
[01:28:10.807]     if (FALSE) {
[01:28:10.807]     }
[01:28:10.807]     else {
[01:28:10.807]         if (TRUE) {
[01:28:10.807]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.807]                 open = "w")
[01:28:10.807]         }
[01:28:10.807]         else {
[01:28:10.807]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.807]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.807]         }
[01:28:10.807]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.807]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.807]             base::sink(type = "output", split = FALSE)
[01:28:10.807]             base::close(...future.stdout)
[01:28:10.807]         }, add = TRUE)
[01:28:10.807]     }
[01:28:10.807]     ...future.frame <- base::sys.nframe()
[01:28:10.807]     ...future.conditions <- base::list()
[01:28:10.807]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.807]     if (FALSE) {
[01:28:10.807]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.807]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.807]     }
[01:28:10.807]     ...future.result <- base::tryCatch({
[01:28:10.807]         base::withCallingHandlers({
[01:28:10.807]             ...future.value <- base::withVisible(base::local({
[01:28:10.807]                 ...future.makeSendCondition <- base::local({
[01:28:10.807]                   sendCondition <- NULL
[01:28:10.807]                   function(frame = 1L) {
[01:28:10.807]                     if (is.function(sendCondition)) 
[01:28:10.807]                       return(sendCondition)
[01:28:10.807]                     ns <- getNamespace("parallel")
[01:28:10.807]                     if (exists("sendData", mode = "function", 
[01:28:10.807]                       envir = ns)) {
[01:28:10.807]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.807]                         envir = ns)
[01:28:10.807]                       envir <- sys.frame(frame)
[01:28:10.807]                       master <- NULL
[01:28:10.807]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.807]                         !identical(envir, emptyenv())) {
[01:28:10.807]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.807]                           inherits = FALSE)) {
[01:28:10.807]                           master <- get("master", mode = "list", 
[01:28:10.807]                             envir = envir, inherits = FALSE)
[01:28:10.807]                           if (inherits(master, c("SOCKnode", 
[01:28:10.807]                             "SOCK0node"))) {
[01:28:10.807]                             sendCondition <<- function(cond) {
[01:28:10.807]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.807]                                 success = TRUE)
[01:28:10.807]                               parallel_sendData(master, data)
[01:28:10.807]                             }
[01:28:10.807]                             return(sendCondition)
[01:28:10.807]                           }
[01:28:10.807]                         }
[01:28:10.807]                         frame <- frame + 1L
[01:28:10.807]                         envir <- sys.frame(frame)
[01:28:10.807]                       }
[01:28:10.807]                     }
[01:28:10.807]                     sendCondition <<- function(cond) NULL
[01:28:10.807]                   }
[01:28:10.807]                 })
[01:28:10.807]                 withCallingHandlers({
[01:28:10.807]                   {
[01:28:10.807]                     b <- a * ii
[01:28:10.807]                     a <- 0
[01:28:10.807]                     b
[01:28:10.807]                   }
[01:28:10.807]                 }, immediateCondition = function(cond) {
[01:28:10.807]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.807]                   sendCondition(cond)
[01:28:10.807]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.807]                   {
[01:28:10.807]                     inherits <- base::inherits
[01:28:10.807]                     invokeRestart <- base::invokeRestart
[01:28:10.807]                     is.null <- base::is.null
[01:28:10.807]                     muffled <- FALSE
[01:28:10.807]                     if (inherits(cond, "message")) {
[01:28:10.807]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.807]                       if (muffled) 
[01:28:10.807]                         invokeRestart("muffleMessage")
[01:28:10.807]                     }
[01:28:10.807]                     else if (inherits(cond, "warning")) {
[01:28:10.807]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.807]                       if (muffled) 
[01:28:10.807]                         invokeRestart("muffleWarning")
[01:28:10.807]                     }
[01:28:10.807]                     else if (inherits(cond, "condition")) {
[01:28:10.807]                       if (!is.null(pattern)) {
[01:28:10.807]                         computeRestarts <- base::computeRestarts
[01:28:10.807]                         grepl <- base::grepl
[01:28:10.807]                         restarts <- computeRestarts(cond)
[01:28:10.807]                         for (restart in restarts) {
[01:28:10.807]                           name <- restart$name
[01:28:10.807]                           if (is.null(name)) 
[01:28:10.807]                             next
[01:28:10.807]                           if (!grepl(pattern, name)) 
[01:28:10.807]                             next
[01:28:10.807]                           invokeRestart(restart)
[01:28:10.807]                           muffled <- TRUE
[01:28:10.807]                           break
[01:28:10.807]                         }
[01:28:10.807]                       }
[01:28:10.807]                     }
[01:28:10.807]                     invisible(muffled)
[01:28:10.807]                   }
[01:28:10.807]                   muffleCondition(cond)
[01:28:10.807]                 })
[01:28:10.807]             }))
[01:28:10.807]             future::FutureResult(value = ...future.value$value, 
[01:28:10.807]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.807]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.807]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.807]                     ...future.globalenv.names))
[01:28:10.807]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.807]         }, condition = base::local({
[01:28:10.807]             c <- base::c
[01:28:10.807]             inherits <- base::inherits
[01:28:10.807]             invokeRestart <- base::invokeRestart
[01:28:10.807]             length <- base::length
[01:28:10.807]             list <- base::list
[01:28:10.807]             seq.int <- base::seq.int
[01:28:10.807]             signalCondition <- base::signalCondition
[01:28:10.807]             sys.calls <- base::sys.calls
[01:28:10.807]             `[[` <- base::`[[`
[01:28:10.807]             `+` <- base::`+`
[01:28:10.807]             `<<-` <- base::`<<-`
[01:28:10.807]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.807]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.807]                   3L)]
[01:28:10.807]             }
[01:28:10.807]             function(cond) {
[01:28:10.807]                 is_error <- inherits(cond, "error")
[01:28:10.807]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.807]                   NULL)
[01:28:10.807]                 if (is_error) {
[01:28:10.807]                   sessionInformation <- function() {
[01:28:10.807]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.807]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.807]                       search = base::search(), system = base::Sys.info())
[01:28:10.807]                   }
[01:28:10.807]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.807]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.807]                     cond$call), session = sessionInformation(), 
[01:28:10.807]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.807]                   signalCondition(cond)
[01:28:10.807]                 }
[01:28:10.807]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.807]                 "immediateCondition"))) {
[01:28:10.807]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.807]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.807]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.807]                   if (TRUE && !signal) {
[01:28:10.807]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.807]                     {
[01:28:10.807]                       inherits <- base::inherits
[01:28:10.807]                       invokeRestart <- base::invokeRestart
[01:28:10.807]                       is.null <- base::is.null
[01:28:10.807]                       muffled <- FALSE
[01:28:10.807]                       if (inherits(cond, "message")) {
[01:28:10.807]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.807]                         if (muffled) 
[01:28:10.807]                           invokeRestart("muffleMessage")
[01:28:10.807]                       }
[01:28:10.807]                       else if (inherits(cond, "warning")) {
[01:28:10.807]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.807]                         if (muffled) 
[01:28:10.807]                           invokeRestart("muffleWarning")
[01:28:10.807]                       }
[01:28:10.807]                       else if (inherits(cond, "condition")) {
[01:28:10.807]                         if (!is.null(pattern)) {
[01:28:10.807]                           computeRestarts <- base::computeRestarts
[01:28:10.807]                           grepl <- base::grepl
[01:28:10.807]                           restarts <- computeRestarts(cond)
[01:28:10.807]                           for (restart in restarts) {
[01:28:10.807]                             name <- restart$name
[01:28:10.807]                             if (is.null(name)) 
[01:28:10.807]                               next
[01:28:10.807]                             if (!grepl(pattern, name)) 
[01:28:10.807]                               next
[01:28:10.807]                             invokeRestart(restart)
[01:28:10.807]                             muffled <- TRUE
[01:28:10.807]                             break
[01:28:10.807]                           }
[01:28:10.807]                         }
[01:28:10.807]                       }
[01:28:10.807]                       invisible(muffled)
[01:28:10.807]                     }
[01:28:10.807]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.807]                   }
[01:28:10.807]                 }
[01:28:10.807]                 else {
[01:28:10.807]                   if (TRUE) {
[01:28:10.807]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.807]                     {
[01:28:10.807]                       inherits <- base::inherits
[01:28:10.807]                       invokeRestart <- base::invokeRestart
[01:28:10.807]                       is.null <- base::is.null
[01:28:10.807]                       muffled <- FALSE
[01:28:10.807]                       if (inherits(cond, "message")) {
[01:28:10.807]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.807]                         if (muffled) 
[01:28:10.807]                           invokeRestart("muffleMessage")
[01:28:10.807]                       }
[01:28:10.807]                       else if (inherits(cond, "warning")) {
[01:28:10.807]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.807]                         if (muffled) 
[01:28:10.807]                           invokeRestart("muffleWarning")
[01:28:10.807]                       }
[01:28:10.807]                       else if (inherits(cond, "condition")) {
[01:28:10.807]                         if (!is.null(pattern)) {
[01:28:10.807]                           computeRestarts <- base::computeRestarts
[01:28:10.807]                           grepl <- base::grepl
[01:28:10.807]                           restarts <- computeRestarts(cond)
[01:28:10.807]                           for (restart in restarts) {
[01:28:10.807]                             name <- restart$name
[01:28:10.807]                             if (is.null(name)) 
[01:28:10.807]                               next
[01:28:10.807]                             if (!grepl(pattern, name)) 
[01:28:10.807]                               next
[01:28:10.807]                             invokeRestart(restart)
[01:28:10.807]                             muffled <- TRUE
[01:28:10.807]                             break
[01:28:10.807]                           }
[01:28:10.807]                         }
[01:28:10.807]                       }
[01:28:10.807]                       invisible(muffled)
[01:28:10.807]                     }
[01:28:10.807]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.807]                   }
[01:28:10.807]                 }
[01:28:10.807]             }
[01:28:10.807]         }))
[01:28:10.807]     }, error = function(ex) {
[01:28:10.807]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.807]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.807]                 ...future.rng), started = ...future.startTime, 
[01:28:10.807]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.807]             version = "1.8"), class = "FutureResult")
[01:28:10.807]     }, finally = {
[01:28:10.807]         if (!identical(...future.workdir, getwd())) 
[01:28:10.807]             setwd(...future.workdir)
[01:28:10.807]         {
[01:28:10.807]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.807]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.807]             }
[01:28:10.807]             base::options(...future.oldOptions)
[01:28:10.807]             if (.Platform$OS.type == "windows") {
[01:28:10.807]                 old_names <- names(...future.oldEnvVars)
[01:28:10.807]                 envs <- base::Sys.getenv()
[01:28:10.807]                 names <- names(envs)
[01:28:10.807]                 common <- intersect(names, old_names)
[01:28:10.807]                 added <- setdiff(names, old_names)
[01:28:10.807]                 removed <- setdiff(old_names, names)
[01:28:10.807]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.807]                   envs[common]]
[01:28:10.807]                 NAMES <- toupper(changed)
[01:28:10.807]                 args <- list()
[01:28:10.807]                 for (kk in seq_along(NAMES)) {
[01:28:10.807]                   name <- changed[[kk]]
[01:28:10.807]                   NAME <- NAMES[[kk]]
[01:28:10.807]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.807]                     next
[01:28:10.807]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.807]                 }
[01:28:10.807]                 NAMES <- toupper(added)
[01:28:10.807]                 for (kk in seq_along(NAMES)) {
[01:28:10.807]                   name <- added[[kk]]
[01:28:10.807]                   NAME <- NAMES[[kk]]
[01:28:10.807]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.807]                     next
[01:28:10.807]                   args[[name]] <- ""
[01:28:10.807]                 }
[01:28:10.807]                 NAMES <- toupper(removed)
[01:28:10.807]                 for (kk in seq_along(NAMES)) {
[01:28:10.807]                   name <- removed[[kk]]
[01:28:10.807]                   NAME <- NAMES[[kk]]
[01:28:10.807]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.807]                     next
[01:28:10.807]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.807]                 }
[01:28:10.807]                 if (length(args) > 0) 
[01:28:10.807]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.807]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.807]             }
[01:28:10.807]             else {
[01:28:10.807]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.807]             }
[01:28:10.807]             {
[01:28:10.807]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.807]                   0L) {
[01:28:10.807]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.807]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.807]                   base::options(opts)
[01:28:10.807]                 }
[01:28:10.807]                 {
[01:28:10.807]                   {
[01:28:10.807]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.807]                     NULL
[01:28:10.807]                   }
[01:28:10.807]                   options(future.plan = NULL)
[01:28:10.807]                   if (is.na(NA_character_)) 
[01:28:10.807]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.807]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.807]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.807]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.807]                     envir = parent.frame()) 
[01:28:10.807]                   {
[01:28:10.807]                     if (is.function(workers)) 
[01:28:10.807]                       workers <- workers()
[01:28:10.807]                     workers <- structure(as.integer(workers), 
[01:28:10.807]                       class = class(workers))
[01:28:10.807]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.807]                       workers >= 1)
[01:28:10.807]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.807]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.807]                     }
[01:28:10.807]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.807]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.807]                       envir = envir)
[01:28:10.807]                     if (!future$lazy) 
[01:28:10.807]                       future <- run(future)
[01:28:10.807]                     invisible(future)
[01:28:10.807]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.807]                 }
[01:28:10.807]             }
[01:28:10.807]         }
[01:28:10.807]     })
[01:28:10.807]     if (TRUE) {
[01:28:10.807]         base::sink(type = "output", split = FALSE)
[01:28:10.807]         if (TRUE) {
[01:28:10.807]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.807]         }
[01:28:10.807]         else {
[01:28:10.807]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.807]         }
[01:28:10.807]         base::close(...future.stdout)
[01:28:10.807]         ...future.stdout <- NULL
[01:28:10.807]     }
[01:28:10.807]     ...future.result$conditions <- ...future.conditions
[01:28:10.807]     ...future.result$finished <- base::Sys.time()
[01:28:10.807]     ...future.result
[01:28:10.807] }
[01:28:10.813] Exporting 2 global objects (112 bytes) to cluster node #1 ...
[01:28:10.813] Exporting 'a' (56 bytes) to cluster node #1 ...
[01:28:10.813] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[01:28:10.814] Exporting 'ii' (56 bytes) to cluster node #1 ...
[01:28:10.814] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[01:28:10.814] Exporting 2 global objects (112 bytes) to cluster node #1 ... DONE
[01:28:10.815] MultisessionFuture started
[01:28:10.815] - Launch lazy future ... done
[01:28:10.815] run() for 'MultisessionFuture' ... done
[01:28:10.815] result() for ClusterFuture ...
[01:28:10.816] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.816] - Validating connection of MultisessionFuture
[01:28:10.831] - received message: FutureResult
[01:28:10.831] - Received FutureResult
[01:28:10.831] - Erased future from FutureRegistry
[01:28:10.831] result() for ClusterFuture ...
[01:28:10.832] - result already collected: FutureResult
[01:28:10.832] result() for ClusterFuture ... done
[01:28:10.832] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.832] result() for ClusterFuture ... done
[01:28:10.832] result() for ClusterFuture ...
[01:28:10.832] - result already collected: FutureResult
[01:28:10.833] result() for ClusterFuture ... done
[1] 1 2 3
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.833] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.833] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.834] 
[01:28:10.834] Searching for globals ... DONE
[01:28:10.834] - globals: [0] <none>
[01:28:10.835] getGlobalsAndPackages() ... DONE
[01:28:10.835] run() for 'Future' ...
[01:28:10.835] - state: 'created'
[01:28:10.835] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.850] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.850] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.850]   - Field: 'node'
[01:28:10.850]   - Field: 'label'
[01:28:10.851]   - Field: 'local'
[01:28:10.851]   - Field: 'owner'
[01:28:10.851]   - Field: 'envir'
[01:28:10.851]   - Field: 'workers'
[01:28:10.851]   - Field: 'packages'
[01:28:10.852]   - Field: 'gc'
[01:28:10.852]   - Field: 'conditions'
[01:28:10.852]   - Field: 'persistent'
[01:28:10.852]   - Field: 'expr'
[01:28:10.852]   - Field: 'uuid'
[01:28:10.852]   - Field: 'seed'
[01:28:10.853]   - Field: 'version'
[01:28:10.853]   - Field: 'result'
[01:28:10.853]   - Field: 'asynchronous'
[01:28:10.853]   - Field: 'calls'
[01:28:10.853]   - Field: 'globals'
[01:28:10.853]   - Field: 'stdout'
[01:28:10.854]   - Field: 'earlySignal'
[01:28:10.854]   - Field: 'lazy'
[01:28:10.854]   - Field: 'state'
[01:28:10.855] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.855] - Launch lazy future ...
[01:28:10.855] Packages needed by the future expression (n = 0): <none>
[01:28:10.856] Packages needed by future strategies (n = 0): <none>
[01:28:10.857] {
[01:28:10.857]     {
[01:28:10.857]         {
[01:28:10.857]             ...future.startTime <- base::Sys.time()
[01:28:10.857]             {
[01:28:10.857]                 {
[01:28:10.857]                   {
[01:28:10.857]                     {
[01:28:10.857]                       base::local({
[01:28:10.857]                         has_future <- base::requireNamespace("future", 
[01:28:10.857]                           quietly = TRUE)
[01:28:10.857]                         if (has_future) {
[01:28:10.857]                           ns <- base::getNamespace("future")
[01:28:10.857]                           version <- ns[[".package"]][["version"]]
[01:28:10.857]                           if (is.null(version)) 
[01:28:10.857]                             version <- utils::packageVersion("future")
[01:28:10.857]                         }
[01:28:10.857]                         else {
[01:28:10.857]                           version <- NULL
[01:28:10.857]                         }
[01:28:10.857]                         if (!has_future || version < "1.8.0") {
[01:28:10.857]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.857]                             "", base::R.version$version.string), 
[01:28:10.857]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.857]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.857]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.857]                               "release", "version")], collapse = " "), 
[01:28:10.857]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.857]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.857]                             info)
[01:28:10.857]                           info <- base::paste(info, collapse = "; ")
[01:28:10.857]                           if (!has_future) {
[01:28:10.857]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.857]                               info)
[01:28:10.857]                           }
[01:28:10.857]                           else {
[01:28:10.857]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.857]                               info, version)
[01:28:10.857]                           }
[01:28:10.857]                           base::stop(msg)
[01:28:10.857]                         }
[01:28:10.857]                       })
[01:28:10.857]                     }
[01:28:10.857]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.857]                     base::options(mc.cores = 1L)
[01:28:10.857]                   }
[01:28:10.857]                   options(future.plan = NULL)
[01:28:10.857]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.857]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.857]                 }
[01:28:10.857]                 ...future.workdir <- getwd()
[01:28:10.857]             }
[01:28:10.857]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.857]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.857]         }
[01:28:10.857]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.857]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.857]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.857]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.857]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.857]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.857]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.857]             base::names(...future.oldOptions))
[01:28:10.857]     }
[01:28:10.857]     if (FALSE) {
[01:28:10.857]     }
[01:28:10.857]     else {
[01:28:10.857]         if (TRUE) {
[01:28:10.857]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.857]                 open = "w")
[01:28:10.857]         }
[01:28:10.857]         else {
[01:28:10.857]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.857]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.857]         }
[01:28:10.857]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.857]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.857]             base::sink(type = "output", split = FALSE)
[01:28:10.857]             base::close(...future.stdout)
[01:28:10.857]         }, add = TRUE)
[01:28:10.857]     }
[01:28:10.857]     ...future.frame <- base::sys.nframe()
[01:28:10.857]     ...future.conditions <- base::list()
[01:28:10.857]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.857]     if (FALSE) {
[01:28:10.857]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.857]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.857]     }
[01:28:10.857]     ...future.result <- base::tryCatch({
[01:28:10.857]         base::withCallingHandlers({
[01:28:10.857]             ...future.value <- base::withVisible(base::local({
[01:28:10.857]                 ...future.makeSendCondition <- base::local({
[01:28:10.857]                   sendCondition <- NULL
[01:28:10.857]                   function(frame = 1L) {
[01:28:10.857]                     if (is.function(sendCondition)) 
[01:28:10.857]                       return(sendCondition)
[01:28:10.857]                     ns <- getNamespace("parallel")
[01:28:10.857]                     if (exists("sendData", mode = "function", 
[01:28:10.857]                       envir = ns)) {
[01:28:10.857]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.857]                         envir = ns)
[01:28:10.857]                       envir <- sys.frame(frame)
[01:28:10.857]                       master <- NULL
[01:28:10.857]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.857]                         !identical(envir, emptyenv())) {
[01:28:10.857]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.857]                           inherits = FALSE)) {
[01:28:10.857]                           master <- get("master", mode = "list", 
[01:28:10.857]                             envir = envir, inherits = FALSE)
[01:28:10.857]                           if (inherits(master, c("SOCKnode", 
[01:28:10.857]                             "SOCK0node"))) {
[01:28:10.857]                             sendCondition <<- function(cond) {
[01:28:10.857]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.857]                                 success = TRUE)
[01:28:10.857]                               parallel_sendData(master, data)
[01:28:10.857]                             }
[01:28:10.857]                             return(sendCondition)
[01:28:10.857]                           }
[01:28:10.857]                         }
[01:28:10.857]                         frame <- frame + 1L
[01:28:10.857]                         envir <- sys.frame(frame)
[01:28:10.857]                       }
[01:28:10.857]                     }
[01:28:10.857]                     sendCondition <<- function(cond) NULL
[01:28:10.857]                   }
[01:28:10.857]                 })
[01:28:10.857]                 withCallingHandlers({
[01:28:10.857]                   1
[01:28:10.857]                 }, immediateCondition = function(cond) {
[01:28:10.857]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.857]                   sendCondition(cond)
[01:28:10.857]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.857]                   {
[01:28:10.857]                     inherits <- base::inherits
[01:28:10.857]                     invokeRestart <- base::invokeRestart
[01:28:10.857]                     is.null <- base::is.null
[01:28:10.857]                     muffled <- FALSE
[01:28:10.857]                     if (inherits(cond, "message")) {
[01:28:10.857]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.857]                       if (muffled) 
[01:28:10.857]                         invokeRestart("muffleMessage")
[01:28:10.857]                     }
[01:28:10.857]                     else if (inherits(cond, "warning")) {
[01:28:10.857]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.857]                       if (muffled) 
[01:28:10.857]                         invokeRestart("muffleWarning")
[01:28:10.857]                     }
[01:28:10.857]                     else if (inherits(cond, "condition")) {
[01:28:10.857]                       if (!is.null(pattern)) {
[01:28:10.857]                         computeRestarts <- base::computeRestarts
[01:28:10.857]                         grepl <- base::grepl
[01:28:10.857]                         restarts <- computeRestarts(cond)
[01:28:10.857]                         for (restart in restarts) {
[01:28:10.857]                           name <- restart$name
[01:28:10.857]                           if (is.null(name)) 
[01:28:10.857]                             next
[01:28:10.857]                           if (!grepl(pattern, name)) 
[01:28:10.857]                             next
[01:28:10.857]                           invokeRestart(restart)
[01:28:10.857]                           muffled <- TRUE
[01:28:10.857]                           break
[01:28:10.857]                         }
[01:28:10.857]                       }
[01:28:10.857]                     }
[01:28:10.857]                     invisible(muffled)
[01:28:10.857]                   }
[01:28:10.857]                   muffleCondition(cond)
[01:28:10.857]                 })
[01:28:10.857]             }))
[01:28:10.857]             future::FutureResult(value = ...future.value$value, 
[01:28:10.857]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.857]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.857]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.857]                     ...future.globalenv.names))
[01:28:10.857]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.857]         }, condition = base::local({
[01:28:10.857]             c <- base::c
[01:28:10.857]             inherits <- base::inherits
[01:28:10.857]             invokeRestart <- base::invokeRestart
[01:28:10.857]             length <- base::length
[01:28:10.857]             list <- base::list
[01:28:10.857]             seq.int <- base::seq.int
[01:28:10.857]             signalCondition <- base::signalCondition
[01:28:10.857]             sys.calls <- base::sys.calls
[01:28:10.857]             `[[` <- base::`[[`
[01:28:10.857]             `+` <- base::`+`
[01:28:10.857]             `<<-` <- base::`<<-`
[01:28:10.857]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.857]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.857]                   3L)]
[01:28:10.857]             }
[01:28:10.857]             function(cond) {
[01:28:10.857]                 is_error <- inherits(cond, "error")
[01:28:10.857]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.857]                   NULL)
[01:28:10.857]                 if (is_error) {
[01:28:10.857]                   sessionInformation <- function() {
[01:28:10.857]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.857]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.857]                       search = base::search(), system = base::Sys.info())
[01:28:10.857]                   }
[01:28:10.857]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.857]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.857]                     cond$call), session = sessionInformation(), 
[01:28:10.857]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.857]                   signalCondition(cond)
[01:28:10.857]                 }
[01:28:10.857]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.857]                 "immediateCondition"))) {
[01:28:10.857]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.857]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.857]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.857]                   if (TRUE && !signal) {
[01:28:10.857]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.857]                     {
[01:28:10.857]                       inherits <- base::inherits
[01:28:10.857]                       invokeRestart <- base::invokeRestart
[01:28:10.857]                       is.null <- base::is.null
[01:28:10.857]                       muffled <- FALSE
[01:28:10.857]                       if (inherits(cond, "message")) {
[01:28:10.857]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.857]                         if (muffled) 
[01:28:10.857]                           invokeRestart("muffleMessage")
[01:28:10.857]                       }
[01:28:10.857]                       else if (inherits(cond, "warning")) {
[01:28:10.857]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.857]                         if (muffled) 
[01:28:10.857]                           invokeRestart("muffleWarning")
[01:28:10.857]                       }
[01:28:10.857]                       else if (inherits(cond, "condition")) {
[01:28:10.857]                         if (!is.null(pattern)) {
[01:28:10.857]                           computeRestarts <- base::computeRestarts
[01:28:10.857]                           grepl <- base::grepl
[01:28:10.857]                           restarts <- computeRestarts(cond)
[01:28:10.857]                           for (restart in restarts) {
[01:28:10.857]                             name <- restart$name
[01:28:10.857]                             if (is.null(name)) 
[01:28:10.857]                               next
[01:28:10.857]                             if (!grepl(pattern, name)) 
[01:28:10.857]                               next
[01:28:10.857]                             invokeRestart(restart)
[01:28:10.857]                             muffled <- TRUE
[01:28:10.857]                             break
[01:28:10.857]                           }
[01:28:10.857]                         }
[01:28:10.857]                       }
[01:28:10.857]                       invisible(muffled)
[01:28:10.857]                     }
[01:28:10.857]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.857]                   }
[01:28:10.857]                 }
[01:28:10.857]                 else {
[01:28:10.857]                   if (TRUE) {
[01:28:10.857]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.857]                     {
[01:28:10.857]                       inherits <- base::inherits
[01:28:10.857]                       invokeRestart <- base::invokeRestart
[01:28:10.857]                       is.null <- base::is.null
[01:28:10.857]                       muffled <- FALSE
[01:28:10.857]                       if (inherits(cond, "message")) {
[01:28:10.857]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.857]                         if (muffled) 
[01:28:10.857]                           invokeRestart("muffleMessage")
[01:28:10.857]                       }
[01:28:10.857]                       else if (inherits(cond, "warning")) {
[01:28:10.857]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.857]                         if (muffled) 
[01:28:10.857]                           invokeRestart("muffleWarning")
[01:28:10.857]                       }
[01:28:10.857]                       else if (inherits(cond, "condition")) {
[01:28:10.857]                         if (!is.null(pattern)) {
[01:28:10.857]                           computeRestarts <- base::computeRestarts
[01:28:10.857]                           grepl <- base::grepl
[01:28:10.857]                           restarts <- computeRestarts(cond)
[01:28:10.857]                           for (restart in restarts) {
[01:28:10.857]                             name <- restart$name
[01:28:10.857]                             if (is.null(name)) 
[01:28:10.857]                               next
[01:28:10.857]                             if (!grepl(pattern, name)) 
[01:28:10.857]                               next
[01:28:10.857]                             invokeRestart(restart)
[01:28:10.857]                             muffled <- TRUE
[01:28:10.857]                             break
[01:28:10.857]                           }
[01:28:10.857]                         }
[01:28:10.857]                       }
[01:28:10.857]                       invisible(muffled)
[01:28:10.857]                     }
[01:28:10.857]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.857]                   }
[01:28:10.857]                 }
[01:28:10.857]             }
[01:28:10.857]         }))
[01:28:10.857]     }, error = function(ex) {
[01:28:10.857]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.857]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.857]                 ...future.rng), started = ...future.startTime, 
[01:28:10.857]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.857]             version = "1.8"), class = "FutureResult")
[01:28:10.857]     }, finally = {
[01:28:10.857]         if (!identical(...future.workdir, getwd())) 
[01:28:10.857]             setwd(...future.workdir)
[01:28:10.857]         {
[01:28:10.857]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.857]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.857]             }
[01:28:10.857]             base::options(...future.oldOptions)
[01:28:10.857]             if (.Platform$OS.type == "windows") {
[01:28:10.857]                 old_names <- names(...future.oldEnvVars)
[01:28:10.857]                 envs <- base::Sys.getenv()
[01:28:10.857]                 names <- names(envs)
[01:28:10.857]                 common <- intersect(names, old_names)
[01:28:10.857]                 added <- setdiff(names, old_names)
[01:28:10.857]                 removed <- setdiff(old_names, names)
[01:28:10.857]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.857]                   envs[common]]
[01:28:10.857]                 NAMES <- toupper(changed)
[01:28:10.857]                 args <- list()
[01:28:10.857]                 for (kk in seq_along(NAMES)) {
[01:28:10.857]                   name <- changed[[kk]]
[01:28:10.857]                   NAME <- NAMES[[kk]]
[01:28:10.857]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.857]                     next
[01:28:10.857]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.857]                 }
[01:28:10.857]                 NAMES <- toupper(added)
[01:28:10.857]                 for (kk in seq_along(NAMES)) {
[01:28:10.857]                   name <- added[[kk]]
[01:28:10.857]                   NAME <- NAMES[[kk]]
[01:28:10.857]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.857]                     next
[01:28:10.857]                   args[[name]] <- ""
[01:28:10.857]                 }
[01:28:10.857]                 NAMES <- toupper(removed)
[01:28:10.857]                 for (kk in seq_along(NAMES)) {
[01:28:10.857]                   name <- removed[[kk]]
[01:28:10.857]                   NAME <- NAMES[[kk]]
[01:28:10.857]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.857]                     next
[01:28:10.857]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.857]                 }
[01:28:10.857]                 if (length(args) > 0) 
[01:28:10.857]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.857]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.857]             }
[01:28:10.857]             else {
[01:28:10.857]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.857]             }
[01:28:10.857]             {
[01:28:10.857]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.857]                   0L) {
[01:28:10.857]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.857]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.857]                   base::options(opts)
[01:28:10.857]                 }
[01:28:10.857]                 {
[01:28:10.857]                   {
[01:28:10.857]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.857]                     NULL
[01:28:10.857]                   }
[01:28:10.857]                   options(future.plan = NULL)
[01:28:10.857]                   if (is.na(NA_character_)) 
[01:28:10.857]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.857]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.857]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.857]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.857]                     envir = parent.frame()) 
[01:28:10.857]                   {
[01:28:10.857]                     if (is.function(workers)) 
[01:28:10.857]                       workers <- workers()
[01:28:10.857]                     workers <- structure(as.integer(workers), 
[01:28:10.857]                       class = class(workers))
[01:28:10.857]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.857]                       workers >= 1)
[01:28:10.857]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.857]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.857]                     }
[01:28:10.857]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.857]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.857]                       envir = envir)
[01:28:10.857]                     if (!future$lazy) 
[01:28:10.857]                       future <- run(future)
[01:28:10.857]                     invisible(future)
[01:28:10.857]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.857]                 }
[01:28:10.857]             }
[01:28:10.857]         }
[01:28:10.857]     })
[01:28:10.857]     if (TRUE) {
[01:28:10.857]         base::sink(type = "output", split = FALSE)
[01:28:10.857]         if (TRUE) {
[01:28:10.857]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.857]         }
[01:28:10.857]         else {
[01:28:10.857]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.857]         }
[01:28:10.857]         base::close(...future.stdout)
[01:28:10.857]         ...future.stdout <- NULL
[01:28:10.857]     }
[01:28:10.857]     ...future.result$conditions <- ...future.conditions
[01:28:10.857]     ...future.result$finished <- base::Sys.time()
[01:28:10.857]     ...future.result
[01:28:10.857] }
[01:28:10.866] MultisessionFuture started
[01:28:10.866] - Launch lazy future ... done
[01:28:10.866] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.867] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.867] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.868] - globals found: [3] '+', 'value', 'a'
[01:28:10.868] Searching for globals ... DONE
[01:28:10.868] Resolving globals: TRUE
[01:28:10.869] Resolving any globals that are futures ...
[01:28:10.869] - globals: [3] '+', 'value', 'a'
[01:28:10.869] Resolving any globals that are futures ... DONE
[01:28:10.869] Resolving futures part of globals (recursively) ...
[01:28:10.870] resolve() on list ...
[01:28:10.870]  recursive: 99
[01:28:10.870]  length: 1
[01:28:10.870]  elements: 'a'
[01:28:10.884] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.884] - Validating connection of MultisessionFuture
[01:28:10.885] - received message: FutureResult
[01:28:10.885] - Received FutureResult
[01:28:10.885] - Erased future from FutureRegistry
[01:28:10.885] result() for ClusterFuture ...
[01:28:10.886] - result already collected: FutureResult
[01:28:10.886] result() for ClusterFuture ... done
[01:28:10.886] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.886] Future #1
[01:28:10.886] result() for ClusterFuture ...
[01:28:10.886] - result already collected: FutureResult
[01:28:10.886] result() for ClusterFuture ... done
[01:28:10.887] result() for ClusterFuture ...
[01:28:10.887] - result already collected: FutureResult
[01:28:10.887] result() for ClusterFuture ... done
[01:28:10.887] A MultisessionFuture was resolved
[01:28:10.887]  length: 0 (resolved future 1)
[01:28:10.888] resolve() on list ... DONE
[01:28:10.888] - globals: [1] 'a'
[01:28:10.888] Resolving futures part of globals (recursively) ... DONE
[01:28:10.890] The total size of the 1 globals is 1.59 MiB (1663072 bytes)
[01:28:10.891] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.59 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.59 MiB of class 'environment')
[01:28:10.891] - globals: [1] 'a'
[01:28:10.891] - packages: [1] 'future'
[01:28:10.892] getGlobalsAndPackages() ... DONE
[01:28:10.892] run() for 'Future' ...
[01:28:10.892] - state: 'created'
[01:28:10.892] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.907] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.907] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.907]   - Field: 'node'
[01:28:10.908]   - Field: 'label'
[01:28:10.908]   - Field: 'local'
[01:28:10.908]   - Field: 'owner'
[01:28:10.908]   - Field: 'envir'
[01:28:10.908]   - Field: 'workers'
[01:28:10.908]   - Field: 'packages'
[01:28:10.909]   - Field: 'gc'
[01:28:10.909]   - Field: 'conditions'
[01:28:10.909]   - Field: 'persistent'
[01:28:10.909]   - Field: 'expr'
[01:28:10.909]   - Field: 'uuid'
[01:28:10.909]   - Field: 'seed'
[01:28:10.910]   - Field: 'version'
[01:28:10.910]   - Field: 'result'
[01:28:10.910]   - Field: 'asynchronous'
[01:28:10.910]   - Field: 'calls'
[01:28:10.910]   - Field: 'globals'
[01:28:10.911]   - Field: 'stdout'
[01:28:10.911]   - Field: 'earlySignal'
[01:28:10.911]   - Field: 'lazy'
[01:28:10.911]   - Field: 'state'
[01:28:10.911] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.911] - Launch lazy future ...
[01:28:10.912] Packages needed by the future expression (n = 1): 'future'
[01:28:10.912] Packages needed by future strategies (n = 0): <none>
[01:28:10.913] {
[01:28:10.913]     {
[01:28:10.913]         {
[01:28:10.913]             ...future.startTime <- base::Sys.time()
[01:28:10.913]             {
[01:28:10.913]                 {
[01:28:10.913]                   {
[01:28:10.913]                     {
[01:28:10.913]                       {
[01:28:10.913]                         base::local({
[01:28:10.913]                           has_future <- base::requireNamespace("future", 
[01:28:10.913]                             quietly = TRUE)
[01:28:10.913]                           if (has_future) {
[01:28:10.913]                             ns <- base::getNamespace("future")
[01:28:10.913]                             version <- ns[[".package"]][["version"]]
[01:28:10.913]                             if (is.null(version)) 
[01:28:10.913]                               version <- utils::packageVersion("future")
[01:28:10.913]                           }
[01:28:10.913]                           else {
[01:28:10.913]                             version <- NULL
[01:28:10.913]                           }
[01:28:10.913]                           if (!has_future || version < "1.8.0") {
[01:28:10.913]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.913]                               "", base::R.version$version.string), 
[01:28:10.913]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:10.913]                                 base::R.version$platform, 8 * 
[01:28:10.913]                                   base::.Machine$sizeof.pointer), 
[01:28:10.913]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.913]                                 "release", "version")], collapse = " "), 
[01:28:10.913]                               hostname = base::Sys.info()[["nodename"]])
[01:28:10.913]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.913]                               info)
[01:28:10.913]                             info <- base::paste(info, collapse = "; ")
[01:28:10.913]                             if (!has_future) {
[01:28:10.913]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.913]                                 info)
[01:28:10.913]                             }
[01:28:10.913]                             else {
[01:28:10.913]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.913]                                 info, version)
[01:28:10.913]                             }
[01:28:10.913]                             base::stop(msg)
[01:28:10.913]                           }
[01:28:10.913]                         })
[01:28:10.913]                       }
[01:28:10.913]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.913]                       base::options(mc.cores = 1L)
[01:28:10.913]                     }
[01:28:10.913]                     base::local({
[01:28:10.913]                       for (pkg in "future") {
[01:28:10.913]                         base::loadNamespace(pkg)
[01:28:10.913]                         base::library(pkg, character.only = TRUE)
[01:28:10.913]                       }
[01:28:10.913]                     })
[01:28:10.913]                   }
[01:28:10.913]                   options(future.plan = NULL)
[01:28:10.913]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.913]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.913]                 }
[01:28:10.913]                 ...future.workdir <- getwd()
[01:28:10.913]             }
[01:28:10.913]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.913]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.913]         }
[01:28:10.913]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.913]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.913]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.913]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.913]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.913]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.913]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.913]             base::names(...future.oldOptions))
[01:28:10.913]     }
[01:28:10.913]     if (FALSE) {
[01:28:10.913]     }
[01:28:10.913]     else {
[01:28:10.913]         if (TRUE) {
[01:28:10.913]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.913]                 open = "w")
[01:28:10.913]         }
[01:28:10.913]         else {
[01:28:10.913]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.913]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.913]         }
[01:28:10.913]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.913]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.913]             base::sink(type = "output", split = FALSE)
[01:28:10.913]             base::close(...future.stdout)
[01:28:10.913]         }, add = TRUE)
[01:28:10.913]     }
[01:28:10.913]     ...future.frame <- base::sys.nframe()
[01:28:10.913]     ...future.conditions <- base::list()
[01:28:10.913]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.913]     if (FALSE) {
[01:28:10.913]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.913]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.913]     }
[01:28:10.913]     ...future.result <- base::tryCatch({
[01:28:10.913]         base::withCallingHandlers({
[01:28:10.913]             ...future.value <- base::withVisible(base::local({
[01:28:10.913]                 ...future.makeSendCondition <- base::local({
[01:28:10.913]                   sendCondition <- NULL
[01:28:10.913]                   function(frame = 1L) {
[01:28:10.913]                     if (is.function(sendCondition)) 
[01:28:10.913]                       return(sendCondition)
[01:28:10.913]                     ns <- getNamespace("parallel")
[01:28:10.913]                     if (exists("sendData", mode = "function", 
[01:28:10.913]                       envir = ns)) {
[01:28:10.913]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.913]                         envir = ns)
[01:28:10.913]                       envir <- sys.frame(frame)
[01:28:10.913]                       master <- NULL
[01:28:10.913]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.913]                         !identical(envir, emptyenv())) {
[01:28:10.913]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.913]                           inherits = FALSE)) {
[01:28:10.913]                           master <- get("master", mode = "list", 
[01:28:10.913]                             envir = envir, inherits = FALSE)
[01:28:10.913]                           if (inherits(master, c("SOCKnode", 
[01:28:10.913]                             "SOCK0node"))) {
[01:28:10.913]                             sendCondition <<- function(cond) {
[01:28:10.913]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.913]                                 success = TRUE)
[01:28:10.913]                               parallel_sendData(master, data)
[01:28:10.913]                             }
[01:28:10.913]                             return(sendCondition)
[01:28:10.913]                           }
[01:28:10.913]                         }
[01:28:10.913]                         frame <- frame + 1L
[01:28:10.913]                         envir <- sys.frame(frame)
[01:28:10.913]                       }
[01:28:10.913]                     }
[01:28:10.913]                     sendCondition <<- function(cond) NULL
[01:28:10.913]                   }
[01:28:10.913]                 })
[01:28:10.913]                 withCallingHandlers({
[01:28:10.913]                   value(a) + 1
[01:28:10.913]                 }, immediateCondition = function(cond) {
[01:28:10.913]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.913]                   sendCondition(cond)
[01:28:10.913]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.913]                   {
[01:28:10.913]                     inherits <- base::inherits
[01:28:10.913]                     invokeRestart <- base::invokeRestart
[01:28:10.913]                     is.null <- base::is.null
[01:28:10.913]                     muffled <- FALSE
[01:28:10.913]                     if (inherits(cond, "message")) {
[01:28:10.913]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.913]                       if (muffled) 
[01:28:10.913]                         invokeRestart("muffleMessage")
[01:28:10.913]                     }
[01:28:10.913]                     else if (inherits(cond, "warning")) {
[01:28:10.913]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.913]                       if (muffled) 
[01:28:10.913]                         invokeRestart("muffleWarning")
[01:28:10.913]                     }
[01:28:10.913]                     else if (inherits(cond, "condition")) {
[01:28:10.913]                       if (!is.null(pattern)) {
[01:28:10.913]                         computeRestarts <- base::computeRestarts
[01:28:10.913]                         grepl <- base::grepl
[01:28:10.913]                         restarts <- computeRestarts(cond)
[01:28:10.913]                         for (restart in restarts) {
[01:28:10.913]                           name <- restart$name
[01:28:10.913]                           if (is.null(name)) 
[01:28:10.913]                             next
[01:28:10.913]                           if (!grepl(pattern, name)) 
[01:28:10.913]                             next
[01:28:10.913]                           invokeRestart(restart)
[01:28:10.913]                           muffled <- TRUE
[01:28:10.913]                           break
[01:28:10.913]                         }
[01:28:10.913]                       }
[01:28:10.913]                     }
[01:28:10.913]                     invisible(muffled)
[01:28:10.913]                   }
[01:28:10.913]                   muffleCondition(cond)
[01:28:10.913]                 })
[01:28:10.913]             }))
[01:28:10.913]             future::FutureResult(value = ...future.value$value, 
[01:28:10.913]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.913]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.913]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.913]                     ...future.globalenv.names))
[01:28:10.913]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.913]         }, condition = base::local({
[01:28:10.913]             c <- base::c
[01:28:10.913]             inherits <- base::inherits
[01:28:10.913]             invokeRestart <- base::invokeRestart
[01:28:10.913]             length <- base::length
[01:28:10.913]             list <- base::list
[01:28:10.913]             seq.int <- base::seq.int
[01:28:10.913]             signalCondition <- base::signalCondition
[01:28:10.913]             sys.calls <- base::sys.calls
[01:28:10.913]             `[[` <- base::`[[`
[01:28:10.913]             `+` <- base::`+`
[01:28:10.913]             `<<-` <- base::`<<-`
[01:28:10.913]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.913]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.913]                   3L)]
[01:28:10.913]             }
[01:28:10.913]             function(cond) {
[01:28:10.913]                 is_error <- inherits(cond, "error")
[01:28:10.913]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.913]                   NULL)
[01:28:10.913]                 if (is_error) {
[01:28:10.913]                   sessionInformation <- function() {
[01:28:10.913]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.913]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.913]                       search = base::search(), system = base::Sys.info())
[01:28:10.913]                   }
[01:28:10.913]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.913]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.913]                     cond$call), session = sessionInformation(), 
[01:28:10.913]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.913]                   signalCondition(cond)
[01:28:10.913]                 }
[01:28:10.913]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.913]                 "immediateCondition"))) {
[01:28:10.913]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.913]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.913]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.913]                   if (TRUE && !signal) {
[01:28:10.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.913]                     {
[01:28:10.913]                       inherits <- base::inherits
[01:28:10.913]                       invokeRestart <- base::invokeRestart
[01:28:10.913]                       is.null <- base::is.null
[01:28:10.913]                       muffled <- FALSE
[01:28:10.913]                       if (inherits(cond, "message")) {
[01:28:10.913]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.913]                         if (muffled) 
[01:28:10.913]                           invokeRestart("muffleMessage")
[01:28:10.913]                       }
[01:28:10.913]                       else if (inherits(cond, "warning")) {
[01:28:10.913]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.913]                         if (muffled) 
[01:28:10.913]                           invokeRestart("muffleWarning")
[01:28:10.913]                       }
[01:28:10.913]                       else if (inherits(cond, "condition")) {
[01:28:10.913]                         if (!is.null(pattern)) {
[01:28:10.913]                           computeRestarts <- base::computeRestarts
[01:28:10.913]                           grepl <- base::grepl
[01:28:10.913]                           restarts <- computeRestarts(cond)
[01:28:10.913]                           for (restart in restarts) {
[01:28:10.913]                             name <- restart$name
[01:28:10.913]                             if (is.null(name)) 
[01:28:10.913]                               next
[01:28:10.913]                             if (!grepl(pattern, name)) 
[01:28:10.913]                               next
[01:28:10.913]                             invokeRestart(restart)
[01:28:10.913]                             muffled <- TRUE
[01:28:10.913]                             break
[01:28:10.913]                           }
[01:28:10.913]                         }
[01:28:10.913]                       }
[01:28:10.913]                       invisible(muffled)
[01:28:10.913]                     }
[01:28:10.913]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.913]                   }
[01:28:10.913]                 }
[01:28:10.913]                 else {
[01:28:10.913]                   if (TRUE) {
[01:28:10.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.913]                     {
[01:28:10.913]                       inherits <- base::inherits
[01:28:10.913]                       invokeRestart <- base::invokeRestart
[01:28:10.913]                       is.null <- base::is.null
[01:28:10.913]                       muffled <- FALSE
[01:28:10.913]                       if (inherits(cond, "message")) {
[01:28:10.913]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.913]                         if (muffled) 
[01:28:10.913]                           invokeRestart("muffleMessage")
[01:28:10.913]                       }
[01:28:10.913]                       else if (inherits(cond, "warning")) {
[01:28:10.913]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.913]                         if (muffled) 
[01:28:10.913]                           invokeRestart("muffleWarning")
[01:28:10.913]                       }
[01:28:10.913]                       else if (inherits(cond, "condition")) {
[01:28:10.913]                         if (!is.null(pattern)) {
[01:28:10.913]                           computeRestarts <- base::computeRestarts
[01:28:10.913]                           grepl <- base::grepl
[01:28:10.913]                           restarts <- computeRestarts(cond)
[01:28:10.913]                           for (restart in restarts) {
[01:28:10.913]                             name <- restart$name
[01:28:10.913]                             if (is.null(name)) 
[01:28:10.913]                               next
[01:28:10.913]                             if (!grepl(pattern, name)) 
[01:28:10.913]                               next
[01:28:10.913]                             invokeRestart(restart)
[01:28:10.913]                             muffled <- TRUE
[01:28:10.913]                             break
[01:28:10.913]                           }
[01:28:10.913]                         }
[01:28:10.913]                       }
[01:28:10.913]                       invisible(muffled)
[01:28:10.913]                     }
[01:28:10.913]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.913]                   }
[01:28:10.913]                 }
[01:28:10.913]             }
[01:28:10.913]         }))
[01:28:10.913]     }, error = function(ex) {
[01:28:10.913]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.913]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.913]                 ...future.rng), started = ...future.startTime, 
[01:28:10.913]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.913]             version = "1.8"), class = "FutureResult")
[01:28:10.913]     }, finally = {
[01:28:10.913]         if (!identical(...future.workdir, getwd())) 
[01:28:10.913]             setwd(...future.workdir)
[01:28:10.913]         {
[01:28:10.913]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.913]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.913]             }
[01:28:10.913]             base::options(...future.oldOptions)
[01:28:10.913]             if (.Platform$OS.type == "windows") {
[01:28:10.913]                 old_names <- names(...future.oldEnvVars)
[01:28:10.913]                 envs <- base::Sys.getenv()
[01:28:10.913]                 names <- names(envs)
[01:28:10.913]                 common <- intersect(names, old_names)
[01:28:10.913]                 added <- setdiff(names, old_names)
[01:28:10.913]                 removed <- setdiff(old_names, names)
[01:28:10.913]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.913]                   envs[common]]
[01:28:10.913]                 NAMES <- toupper(changed)
[01:28:10.913]                 args <- list()
[01:28:10.913]                 for (kk in seq_along(NAMES)) {
[01:28:10.913]                   name <- changed[[kk]]
[01:28:10.913]                   NAME <- NAMES[[kk]]
[01:28:10.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.913]                     next
[01:28:10.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.913]                 }
[01:28:10.913]                 NAMES <- toupper(added)
[01:28:10.913]                 for (kk in seq_along(NAMES)) {
[01:28:10.913]                   name <- added[[kk]]
[01:28:10.913]                   NAME <- NAMES[[kk]]
[01:28:10.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.913]                     next
[01:28:10.913]                   args[[name]] <- ""
[01:28:10.913]                 }
[01:28:10.913]                 NAMES <- toupper(removed)
[01:28:10.913]                 for (kk in seq_along(NAMES)) {
[01:28:10.913]                   name <- removed[[kk]]
[01:28:10.913]                   NAME <- NAMES[[kk]]
[01:28:10.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.913]                     next
[01:28:10.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.913]                 }
[01:28:10.913]                 if (length(args) > 0) 
[01:28:10.913]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.913]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.913]             }
[01:28:10.913]             else {
[01:28:10.913]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.913]             }
[01:28:10.913]             {
[01:28:10.913]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.913]                   0L) {
[01:28:10.913]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.913]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.913]                   base::options(opts)
[01:28:10.913]                 }
[01:28:10.913]                 {
[01:28:10.913]                   {
[01:28:10.913]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.913]                     NULL
[01:28:10.913]                   }
[01:28:10.913]                   options(future.plan = NULL)
[01:28:10.913]                   if (is.na(NA_character_)) 
[01:28:10.913]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.913]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.913]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.913]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.913]                     envir = parent.frame()) 
[01:28:10.913]                   {
[01:28:10.913]                     if (is.function(workers)) 
[01:28:10.913]                       workers <- workers()
[01:28:10.913]                     workers <- structure(as.integer(workers), 
[01:28:10.913]                       class = class(workers))
[01:28:10.913]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.913]                       workers >= 1)
[01:28:10.913]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.913]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.913]                     }
[01:28:10.913]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.913]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.913]                       envir = envir)
[01:28:10.913]                     if (!future$lazy) 
[01:28:10.913]                       future <- run(future)
[01:28:10.913]                     invisible(future)
[01:28:10.913]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.913]                 }
[01:28:10.913]             }
[01:28:10.913]         }
[01:28:10.913]     })
[01:28:10.913]     if (TRUE) {
[01:28:10.913]         base::sink(type = "output", split = FALSE)
[01:28:10.913]         if (TRUE) {
[01:28:10.913]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.913]         }
[01:28:10.913]         else {
[01:28:10.913]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.913]         }
[01:28:10.913]         base::close(...future.stdout)
[01:28:10.913]         ...future.stdout <- NULL
[01:28:10.913]     }
[01:28:10.913]     ...future.result$conditions <- ...future.conditions
[01:28:10.913]     ...future.result$finished <- base::Sys.time()
[01:28:10.913]     ...future.result
[01:28:10.913] }
[01:28:10.918] Exporting 1 global objects (1.59 MiB) to cluster node #1 ...
[01:28:10.921] Exporting 'a' (1.59 MiB) to cluster node #1 ...
[01:28:10.932] Exporting 'a' (1.59 MiB) to cluster node #1 ... DONE
[01:28:10.933] Exporting 1 global objects (1.59 MiB) to cluster node #1 ... DONE
[01:28:10.933] MultisessionFuture started
[01:28:10.933] - Launch lazy future ... done
[01:28:10.934] run() for 'MultisessionFuture' ... done
[01:28:10.934] result() for ClusterFuture ...
[01:28:10.934] receiveMessageFromWorker() for ClusterFuture ...
[01:28:10.934] - Validating connection of MultisessionFuture
[01:28:10.957] - received message: FutureResult
[01:28:10.958] - Received FutureResult
[01:28:10.958] - Erased future from FutureRegistry
[01:28:10.958] result() for ClusterFuture ...
[01:28:10.958] - result already collected: FutureResult
[01:28:10.958] result() for ClusterFuture ... done
[01:28:10.958] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:10.959] result() for ClusterFuture ... done
[01:28:10.959] result() for ClusterFuture ...
[01:28:10.959] - result already collected: FutureResult
[01:28:10.959] result() for ClusterFuture ... done
value(b) = 2
[01:28:10.959] result() for ClusterFuture ...
[01:28:10.960] - result already collected: FutureResult
[01:28:10.960] result() for ClusterFuture ... done
[01:28:10.960] result() for ClusterFuture ...
[01:28:10.960] - result already collected: FutureResult
[01:28:10.960] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.961] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.961] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.962] 
[01:28:10.962] Searching for globals ... DONE
[01:28:10.962] - globals: [0] <none>
[01:28:10.962] getGlobalsAndPackages() ... DONE
[01:28:10.962] run() for 'Future' ...
[01:28:10.963] - state: 'created'
[01:28:10.963] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:10.977] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:10.977] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:10.978]   - Field: 'node'
[01:28:10.978]   - Field: 'label'
[01:28:10.978]   - Field: 'local'
[01:28:10.978]   - Field: 'owner'
[01:28:10.978]   - Field: 'envir'
[01:28:10.979]   - Field: 'workers'
[01:28:10.979]   - Field: 'packages'
[01:28:10.979]   - Field: 'gc'
[01:28:10.979]   - Field: 'conditions'
[01:28:10.979]   - Field: 'persistent'
[01:28:10.980]   - Field: 'expr'
[01:28:10.980]   - Field: 'uuid'
[01:28:10.980]   - Field: 'seed'
[01:28:10.980]   - Field: 'version'
[01:28:10.980]   - Field: 'result'
[01:28:10.980]   - Field: 'asynchronous'
[01:28:10.981]   - Field: 'calls'
[01:28:10.981]   - Field: 'globals'
[01:28:10.981]   - Field: 'stdout'
[01:28:10.981]   - Field: 'earlySignal'
[01:28:10.981]   - Field: 'lazy'
[01:28:10.981]   - Field: 'state'
[01:28:10.982] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:10.982] - Launch lazy future ...
[01:28:10.982] Packages needed by the future expression (n = 0): <none>
[01:28:10.982] Packages needed by future strategies (n = 0): <none>
[01:28:10.983] {
[01:28:10.983]     {
[01:28:10.983]         {
[01:28:10.983]             ...future.startTime <- base::Sys.time()
[01:28:10.983]             {
[01:28:10.983]                 {
[01:28:10.983]                   {
[01:28:10.983]                     {
[01:28:10.983]                       base::local({
[01:28:10.983]                         has_future <- base::requireNamespace("future", 
[01:28:10.983]                           quietly = TRUE)
[01:28:10.983]                         if (has_future) {
[01:28:10.983]                           ns <- base::getNamespace("future")
[01:28:10.983]                           version <- ns[[".package"]][["version"]]
[01:28:10.983]                           if (is.null(version)) 
[01:28:10.983]                             version <- utils::packageVersion("future")
[01:28:10.983]                         }
[01:28:10.983]                         else {
[01:28:10.983]                           version <- NULL
[01:28:10.983]                         }
[01:28:10.983]                         if (!has_future || version < "1.8.0") {
[01:28:10.983]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:10.983]                             "", base::R.version$version.string), 
[01:28:10.983]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:10.983]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:10.983]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:10.983]                               "release", "version")], collapse = " "), 
[01:28:10.983]                             hostname = base::Sys.info()[["nodename"]])
[01:28:10.983]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:10.983]                             info)
[01:28:10.983]                           info <- base::paste(info, collapse = "; ")
[01:28:10.983]                           if (!has_future) {
[01:28:10.983]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:10.983]                               info)
[01:28:10.983]                           }
[01:28:10.983]                           else {
[01:28:10.983]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:10.983]                               info, version)
[01:28:10.983]                           }
[01:28:10.983]                           base::stop(msg)
[01:28:10.983]                         }
[01:28:10.983]                       })
[01:28:10.983]                     }
[01:28:10.983]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:10.983]                     base::options(mc.cores = 1L)
[01:28:10.983]                   }
[01:28:10.983]                   options(future.plan = NULL)
[01:28:10.983]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.983]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:10.983]                 }
[01:28:10.983]                 ...future.workdir <- getwd()
[01:28:10.983]             }
[01:28:10.983]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:10.983]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:10.983]         }
[01:28:10.983]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:10.983]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:10.983]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:10.983]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:10.983]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:10.983]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:10.983]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:10.983]             base::names(...future.oldOptions))
[01:28:10.983]     }
[01:28:10.983]     if (FALSE) {
[01:28:10.983]     }
[01:28:10.983]     else {
[01:28:10.983]         if (TRUE) {
[01:28:10.983]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:10.983]                 open = "w")
[01:28:10.983]         }
[01:28:10.983]         else {
[01:28:10.983]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:10.983]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:10.983]         }
[01:28:10.983]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:10.983]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:10.983]             base::sink(type = "output", split = FALSE)
[01:28:10.983]             base::close(...future.stdout)
[01:28:10.983]         }, add = TRUE)
[01:28:10.983]     }
[01:28:10.983]     ...future.frame <- base::sys.nframe()
[01:28:10.983]     ...future.conditions <- base::list()
[01:28:10.983]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:10.983]     if (FALSE) {
[01:28:10.983]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:10.983]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:10.983]     }
[01:28:10.983]     ...future.result <- base::tryCatch({
[01:28:10.983]         base::withCallingHandlers({
[01:28:10.983]             ...future.value <- base::withVisible(base::local({
[01:28:10.983]                 ...future.makeSendCondition <- base::local({
[01:28:10.983]                   sendCondition <- NULL
[01:28:10.983]                   function(frame = 1L) {
[01:28:10.983]                     if (is.function(sendCondition)) 
[01:28:10.983]                       return(sendCondition)
[01:28:10.983]                     ns <- getNamespace("parallel")
[01:28:10.983]                     if (exists("sendData", mode = "function", 
[01:28:10.983]                       envir = ns)) {
[01:28:10.983]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:10.983]                         envir = ns)
[01:28:10.983]                       envir <- sys.frame(frame)
[01:28:10.983]                       master <- NULL
[01:28:10.983]                       while (!identical(envir, .GlobalEnv) && 
[01:28:10.983]                         !identical(envir, emptyenv())) {
[01:28:10.983]                         if (exists("master", mode = "list", envir = envir, 
[01:28:10.983]                           inherits = FALSE)) {
[01:28:10.983]                           master <- get("master", mode = "list", 
[01:28:10.983]                             envir = envir, inherits = FALSE)
[01:28:10.983]                           if (inherits(master, c("SOCKnode", 
[01:28:10.983]                             "SOCK0node"))) {
[01:28:10.983]                             sendCondition <<- function(cond) {
[01:28:10.983]                               data <- list(type = "VALUE", value = cond, 
[01:28:10.983]                                 success = TRUE)
[01:28:10.983]                               parallel_sendData(master, data)
[01:28:10.983]                             }
[01:28:10.983]                             return(sendCondition)
[01:28:10.983]                           }
[01:28:10.983]                         }
[01:28:10.983]                         frame <- frame + 1L
[01:28:10.983]                         envir <- sys.frame(frame)
[01:28:10.983]                       }
[01:28:10.983]                     }
[01:28:10.983]                     sendCondition <<- function(cond) NULL
[01:28:10.983]                   }
[01:28:10.983]                 })
[01:28:10.983]                 withCallingHandlers({
[01:28:10.983]                   1
[01:28:10.983]                 }, immediateCondition = function(cond) {
[01:28:10.983]                   sendCondition <- ...future.makeSendCondition()
[01:28:10.983]                   sendCondition(cond)
[01:28:10.983]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.983]                   {
[01:28:10.983]                     inherits <- base::inherits
[01:28:10.983]                     invokeRestart <- base::invokeRestart
[01:28:10.983]                     is.null <- base::is.null
[01:28:10.983]                     muffled <- FALSE
[01:28:10.983]                     if (inherits(cond, "message")) {
[01:28:10.983]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:10.983]                       if (muffled) 
[01:28:10.983]                         invokeRestart("muffleMessage")
[01:28:10.983]                     }
[01:28:10.983]                     else if (inherits(cond, "warning")) {
[01:28:10.983]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:10.983]                       if (muffled) 
[01:28:10.983]                         invokeRestart("muffleWarning")
[01:28:10.983]                     }
[01:28:10.983]                     else if (inherits(cond, "condition")) {
[01:28:10.983]                       if (!is.null(pattern)) {
[01:28:10.983]                         computeRestarts <- base::computeRestarts
[01:28:10.983]                         grepl <- base::grepl
[01:28:10.983]                         restarts <- computeRestarts(cond)
[01:28:10.983]                         for (restart in restarts) {
[01:28:10.983]                           name <- restart$name
[01:28:10.983]                           if (is.null(name)) 
[01:28:10.983]                             next
[01:28:10.983]                           if (!grepl(pattern, name)) 
[01:28:10.983]                             next
[01:28:10.983]                           invokeRestart(restart)
[01:28:10.983]                           muffled <- TRUE
[01:28:10.983]                           break
[01:28:10.983]                         }
[01:28:10.983]                       }
[01:28:10.983]                     }
[01:28:10.983]                     invisible(muffled)
[01:28:10.983]                   }
[01:28:10.983]                   muffleCondition(cond)
[01:28:10.983]                 })
[01:28:10.983]             }))
[01:28:10.983]             future::FutureResult(value = ...future.value$value, 
[01:28:10.983]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.983]                   ...future.rng), globalenv = if (FALSE) 
[01:28:10.983]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:10.983]                     ...future.globalenv.names))
[01:28:10.983]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:10.983]         }, condition = base::local({
[01:28:10.983]             c <- base::c
[01:28:10.983]             inherits <- base::inherits
[01:28:10.983]             invokeRestart <- base::invokeRestart
[01:28:10.983]             length <- base::length
[01:28:10.983]             list <- base::list
[01:28:10.983]             seq.int <- base::seq.int
[01:28:10.983]             signalCondition <- base::signalCondition
[01:28:10.983]             sys.calls <- base::sys.calls
[01:28:10.983]             `[[` <- base::`[[`
[01:28:10.983]             `+` <- base::`+`
[01:28:10.983]             `<<-` <- base::`<<-`
[01:28:10.983]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:10.983]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:10.983]                   3L)]
[01:28:10.983]             }
[01:28:10.983]             function(cond) {
[01:28:10.983]                 is_error <- inherits(cond, "error")
[01:28:10.983]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:10.983]                   NULL)
[01:28:10.983]                 if (is_error) {
[01:28:10.983]                   sessionInformation <- function() {
[01:28:10.983]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:10.983]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:10.983]                       search = base::search(), system = base::Sys.info())
[01:28:10.983]                   }
[01:28:10.983]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.983]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:10.983]                     cond$call), session = sessionInformation(), 
[01:28:10.983]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:10.983]                   signalCondition(cond)
[01:28:10.983]                 }
[01:28:10.983]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:10.983]                 "immediateCondition"))) {
[01:28:10.983]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:10.983]                   ...future.conditions[[length(...future.conditions) + 
[01:28:10.983]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:10.983]                   if (TRUE && !signal) {
[01:28:10.983]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.983]                     {
[01:28:10.983]                       inherits <- base::inherits
[01:28:10.983]                       invokeRestart <- base::invokeRestart
[01:28:10.983]                       is.null <- base::is.null
[01:28:10.983]                       muffled <- FALSE
[01:28:10.983]                       if (inherits(cond, "message")) {
[01:28:10.983]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.983]                         if (muffled) 
[01:28:10.983]                           invokeRestart("muffleMessage")
[01:28:10.983]                       }
[01:28:10.983]                       else if (inherits(cond, "warning")) {
[01:28:10.983]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.983]                         if (muffled) 
[01:28:10.983]                           invokeRestart("muffleWarning")
[01:28:10.983]                       }
[01:28:10.983]                       else if (inherits(cond, "condition")) {
[01:28:10.983]                         if (!is.null(pattern)) {
[01:28:10.983]                           computeRestarts <- base::computeRestarts
[01:28:10.983]                           grepl <- base::grepl
[01:28:10.983]                           restarts <- computeRestarts(cond)
[01:28:10.983]                           for (restart in restarts) {
[01:28:10.983]                             name <- restart$name
[01:28:10.983]                             if (is.null(name)) 
[01:28:10.983]                               next
[01:28:10.983]                             if (!grepl(pattern, name)) 
[01:28:10.983]                               next
[01:28:10.983]                             invokeRestart(restart)
[01:28:10.983]                             muffled <- TRUE
[01:28:10.983]                             break
[01:28:10.983]                           }
[01:28:10.983]                         }
[01:28:10.983]                       }
[01:28:10.983]                       invisible(muffled)
[01:28:10.983]                     }
[01:28:10.983]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.983]                   }
[01:28:10.983]                 }
[01:28:10.983]                 else {
[01:28:10.983]                   if (TRUE) {
[01:28:10.983]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:10.983]                     {
[01:28:10.983]                       inherits <- base::inherits
[01:28:10.983]                       invokeRestart <- base::invokeRestart
[01:28:10.983]                       is.null <- base::is.null
[01:28:10.983]                       muffled <- FALSE
[01:28:10.983]                       if (inherits(cond, "message")) {
[01:28:10.983]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:10.983]                         if (muffled) 
[01:28:10.983]                           invokeRestart("muffleMessage")
[01:28:10.983]                       }
[01:28:10.983]                       else if (inherits(cond, "warning")) {
[01:28:10.983]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:10.983]                         if (muffled) 
[01:28:10.983]                           invokeRestart("muffleWarning")
[01:28:10.983]                       }
[01:28:10.983]                       else if (inherits(cond, "condition")) {
[01:28:10.983]                         if (!is.null(pattern)) {
[01:28:10.983]                           computeRestarts <- base::computeRestarts
[01:28:10.983]                           grepl <- base::grepl
[01:28:10.983]                           restarts <- computeRestarts(cond)
[01:28:10.983]                           for (restart in restarts) {
[01:28:10.983]                             name <- restart$name
[01:28:10.983]                             if (is.null(name)) 
[01:28:10.983]                               next
[01:28:10.983]                             if (!grepl(pattern, name)) 
[01:28:10.983]                               next
[01:28:10.983]                             invokeRestart(restart)
[01:28:10.983]                             muffled <- TRUE
[01:28:10.983]                             break
[01:28:10.983]                           }
[01:28:10.983]                         }
[01:28:10.983]                       }
[01:28:10.983]                       invisible(muffled)
[01:28:10.983]                     }
[01:28:10.983]                     muffleCondition(cond, pattern = "^muffle")
[01:28:10.983]                   }
[01:28:10.983]                 }
[01:28:10.983]             }
[01:28:10.983]         }))
[01:28:10.983]     }, error = function(ex) {
[01:28:10.983]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:10.983]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:10.983]                 ...future.rng), started = ...future.startTime, 
[01:28:10.983]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:10.983]             version = "1.8"), class = "FutureResult")
[01:28:10.983]     }, finally = {
[01:28:10.983]         if (!identical(...future.workdir, getwd())) 
[01:28:10.983]             setwd(...future.workdir)
[01:28:10.983]         {
[01:28:10.983]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:10.983]                 ...future.oldOptions$nwarnings <- NULL
[01:28:10.983]             }
[01:28:10.983]             base::options(...future.oldOptions)
[01:28:10.983]             if (.Platform$OS.type == "windows") {
[01:28:10.983]                 old_names <- names(...future.oldEnvVars)
[01:28:10.983]                 envs <- base::Sys.getenv()
[01:28:10.983]                 names <- names(envs)
[01:28:10.983]                 common <- intersect(names, old_names)
[01:28:10.983]                 added <- setdiff(names, old_names)
[01:28:10.983]                 removed <- setdiff(old_names, names)
[01:28:10.983]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:10.983]                   envs[common]]
[01:28:10.983]                 NAMES <- toupper(changed)
[01:28:10.983]                 args <- list()
[01:28:10.983]                 for (kk in seq_along(NAMES)) {
[01:28:10.983]                   name <- changed[[kk]]
[01:28:10.983]                   NAME <- NAMES[[kk]]
[01:28:10.983]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.983]                     next
[01:28:10.983]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.983]                 }
[01:28:10.983]                 NAMES <- toupper(added)
[01:28:10.983]                 for (kk in seq_along(NAMES)) {
[01:28:10.983]                   name <- added[[kk]]
[01:28:10.983]                   NAME <- NAMES[[kk]]
[01:28:10.983]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.983]                     next
[01:28:10.983]                   args[[name]] <- ""
[01:28:10.983]                 }
[01:28:10.983]                 NAMES <- toupper(removed)
[01:28:10.983]                 for (kk in seq_along(NAMES)) {
[01:28:10.983]                   name <- removed[[kk]]
[01:28:10.983]                   NAME <- NAMES[[kk]]
[01:28:10.983]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:10.983]                     next
[01:28:10.983]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:10.983]                 }
[01:28:10.983]                 if (length(args) > 0) 
[01:28:10.983]                   base::do.call(base::Sys.setenv, args = args)
[01:28:10.983]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:10.983]             }
[01:28:10.983]             else {
[01:28:10.983]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:10.983]             }
[01:28:10.983]             {
[01:28:10.983]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:10.983]                   0L) {
[01:28:10.983]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:10.983]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:10.983]                   base::options(opts)
[01:28:10.983]                 }
[01:28:10.983]                 {
[01:28:10.983]                   {
[01:28:10.983]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:10.983]                     NULL
[01:28:10.983]                   }
[01:28:10.983]                   options(future.plan = NULL)
[01:28:10.983]                   if (is.na(NA_character_)) 
[01:28:10.983]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:10.983]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:10.983]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:10.983]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:10.983]                     envir = parent.frame()) 
[01:28:10.983]                   {
[01:28:10.983]                     if (is.function(workers)) 
[01:28:10.983]                       workers <- workers()
[01:28:10.983]                     workers <- structure(as.integer(workers), 
[01:28:10.983]                       class = class(workers))
[01:28:10.983]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:10.983]                       workers >= 1)
[01:28:10.983]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:10.983]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:10.983]                     }
[01:28:10.983]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:10.983]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:10.983]                       envir = envir)
[01:28:10.983]                     if (!future$lazy) 
[01:28:10.983]                       future <- run(future)
[01:28:10.983]                     invisible(future)
[01:28:10.983]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:10.983]                 }
[01:28:10.983]             }
[01:28:10.983]         }
[01:28:10.983]     })
[01:28:10.983]     if (TRUE) {
[01:28:10.983]         base::sink(type = "output", split = FALSE)
[01:28:10.983]         if (TRUE) {
[01:28:10.983]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:10.983]         }
[01:28:10.983]         else {
[01:28:10.983]             ...future.result["stdout"] <- base::list(NULL)
[01:28:10.983]         }
[01:28:10.983]         base::close(...future.stdout)
[01:28:10.983]         ...future.stdout <- NULL
[01:28:10.983]     }
[01:28:10.983]     ...future.result$conditions <- ...future.conditions
[01:28:10.983]     ...future.result$finished <- base::Sys.time()
[01:28:10.983]     ...future.result
[01:28:10.983] }
[01:28:10.989] MultisessionFuture started
[01:28:10.989] - Launch lazy future ... done
[01:28:10.989] run() for 'MultisessionFuture' ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:10.990] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:10.990] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:10.991] - globals found: [3] '+', 'value', 'a'
[01:28:10.991] Searching for globals ... DONE
[01:28:10.991] Resolving globals: TRUE
[01:28:10.992] Resolving any globals that are futures ...
[01:28:10.992] - globals: [3] '+', 'value', 'a'
[01:28:10.992] Resolving any globals that are futures ... DONE
[01:28:10.992] Resolving futures part of globals (recursively) ...
[01:28:10.993] resolve() on list ...
[01:28:10.993]  recursive: 99
[01:28:10.993]  length: 1
[01:28:10.993]  elements: 'a'
[01:28:11.007] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.007] - Validating connection of MultisessionFuture
[01:28:11.008] - received message: FutureResult
[01:28:11.008] - Received FutureResult
[01:28:11.008] - Erased future from FutureRegistry
[01:28:11.008] result() for ClusterFuture ...
[01:28:11.008] - result already collected: FutureResult
[01:28:11.008] result() for ClusterFuture ... done
[01:28:11.009] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.009] Future #1
[01:28:11.009] result() for ClusterFuture ...
[01:28:11.009] - result already collected: FutureResult
[01:28:11.009] result() for ClusterFuture ... done
[01:28:11.009] result() for ClusterFuture ...
[01:28:11.010] - result already collected: FutureResult
[01:28:11.010] result() for ClusterFuture ... done
[01:28:11.010] A MultisessionFuture was resolved
[01:28:11.010]  length: 0 (resolved future 1)
[01:28:11.010] resolve() on list ... DONE
[01:28:11.011] - globals: [1] 'a'
[01:28:11.011] Resolving futures part of globals (recursively) ... DONE
[01:28:11.016] The total size of the 1 globals is 1.59 MiB (1663072 bytes)
[01:28:11.017] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.59 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.59 MiB of class 'environment')
[01:28:11.017] - globals: [1] 'a'
[01:28:11.017] - packages: [1] 'future'
[01:28:11.018] getGlobalsAndPackages() ... DONE
[01:28:11.018] run() for 'Future' ...
[01:28:11.018] - state: 'created'
[01:28:11.018] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.033] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.033] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.033]   - Field: 'node'
[01:28:11.034]   - Field: 'label'
[01:28:11.034]   - Field: 'local'
[01:28:11.034]   - Field: 'owner'
[01:28:11.034]   - Field: 'envir'
[01:28:11.034]   - Field: 'workers'
[01:28:11.035]   - Field: 'packages'
[01:28:11.035]   - Field: 'gc'
[01:28:11.035]   - Field: 'conditions'
[01:28:11.035]   - Field: 'persistent'
[01:28:11.035]   - Field: 'expr'
[01:28:11.035]   - Field: 'uuid'
[01:28:11.036]   - Field: 'seed'
[01:28:11.036]   - Field: 'version'
[01:28:11.036]   - Field: 'result'
[01:28:11.036]   - Field: 'asynchronous'
[01:28:11.036]   - Field: 'calls'
[01:28:11.036]   - Field: 'globals'
[01:28:11.037]   - Field: 'stdout'
[01:28:11.037]   - Field: 'earlySignal'
[01:28:11.037]   - Field: 'lazy'
[01:28:11.037]   - Field: 'state'
[01:28:11.037] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.038] - Launch lazy future ...
[01:28:11.038] Packages needed by the future expression (n = 1): 'future'
[01:28:11.038] Packages needed by future strategies (n = 0): <none>
[01:28:11.039] {
[01:28:11.039]     {
[01:28:11.039]         {
[01:28:11.039]             ...future.startTime <- base::Sys.time()
[01:28:11.039]             {
[01:28:11.039]                 {
[01:28:11.039]                   {
[01:28:11.039]                     {
[01:28:11.039]                       {
[01:28:11.039]                         base::local({
[01:28:11.039]                           has_future <- base::requireNamespace("future", 
[01:28:11.039]                             quietly = TRUE)
[01:28:11.039]                           if (has_future) {
[01:28:11.039]                             ns <- base::getNamespace("future")
[01:28:11.039]                             version <- ns[[".package"]][["version"]]
[01:28:11.039]                             if (is.null(version)) 
[01:28:11.039]                               version <- utils::packageVersion("future")
[01:28:11.039]                           }
[01:28:11.039]                           else {
[01:28:11.039]                             version <- NULL
[01:28:11.039]                           }
[01:28:11.039]                           if (!has_future || version < "1.8.0") {
[01:28:11.039]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.039]                               "", base::R.version$version.string), 
[01:28:11.039]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:11.039]                                 base::R.version$platform, 8 * 
[01:28:11.039]                                   base::.Machine$sizeof.pointer), 
[01:28:11.039]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.039]                                 "release", "version")], collapse = " "), 
[01:28:11.039]                               hostname = base::Sys.info()[["nodename"]])
[01:28:11.039]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.039]                               info)
[01:28:11.039]                             info <- base::paste(info, collapse = "; ")
[01:28:11.039]                             if (!has_future) {
[01:28:11.039]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.039]                                 info)
[01:28:11.039]                             }
[01:28:11.039]                             else {
[01:28:11.039]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.039]                                 info, version)
[01:28:11.039]                             }
[01:28:11.039]                             base::stop(msg)
[01:28:11.039]                           }
[01:28:11.039]                         })
[01:28:11.039]                       }
[01:28:11.039]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.039]                       base::options(mc.cores = 1L)
[01:28:11.039]                     }
[01:28:11.039]                     base::local({
[01:28:11.039]                       for (pkg in "future") {
[01:28:11.039]                         base::loadNamespace(pkg)
[01:28:11.039]                         base::library(pkg, character.only = TRUE)
[01:28:11.039]                       }
[01:28:11.039]                     })
[01:28:11.039]                   }
[01:28:11.039]                   options(future.plan = NULL)
[01:28:11.039]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.039]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.039]                 }
[01:28:11.039]                 ...future.workdir <- getwd()
[01:28:11.039]             }
[01:28:11.039]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.039]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.039]         }
[01:28:11.039]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.039]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.039]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.039]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.039]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.039]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.039]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.039]             base::names(...future.oldOptions))
[01:28:11.039]     }
[01:28:11.039]     if (FALSE) {
[01:28:11.039]     }
[01:28:11.039]     else {
[01:28:11.039]         if (TRUE) {
[01:28:11.039]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.039]                 open = "w")
[01:28:11.039]         }
[01:28:11.039]         else {
[01:28:11.039]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.039]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.039]         }
[01:28:11.039]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.039]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.039]             base::sink(type = "output", split = FALSE)
[01:28:11.039]             base::close(...future.stdout)
[01:28:11.039]         }, add = TRUE)
[01:28:11.039]     }
[01:28:11.039]     ...future.frame <- base::sys.nframe()
[01:28:11.039]     ...future.conditions <- base::list()
[01:28:11.039]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.039]     if (FALSE) {
[01:28:11.039]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.039]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.039]     }
[01:28:11.039]     ...future.result <- base::tryCatch({
[01:28:11.039]         base::withCallingHandlers({
[01:28:11.039]             ...future.value <- base::withVisible(base::local({
[01:28:11.039]                 ...future.makeSendCondition <- base::local({
[01:28:11.039]                   sendCondition <- NULL
[01:28:11.039]                   function(frame = 1L) {
[01:28:11.039]                     if (is.function(sendCondition)) 
[01:28:11.039]                       return(sendCondition)
[01:28:11.039]                     ns <- getNamespace("parallel")
[01:28:11.039]                     if (exists("sendData", mode = "function", 
[01:28:11.039]                       envir = ns)) {
[01:28:11.039]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.039]                         envir = ns)
[01:28:11.039]                       envir <- sys.frame(frame)
[01:28:11.039]                       master <- NULL
[01:28:11.039]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.039]                         !identical(envir, emptyenv())) {
[01:28:11.039]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.039]                           inherits = FALSE)) {
[01:28:11.039]                           master <- get("master", mode = "list", 
[01:28:11.039]                             envir = envir, inherits = FALSE)
[01:28:11.039]                           if (inherits(master, c("SOCKnode", 
[01:28:11.039]                             "SOCK0node"))) {
[01:28:11.039]                             sendCondition <<- function(cond) {
[01:28:11.039]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.039]                                 success = TRUE)
[01:28:11.039]                               parallel_sendData(master, data)
[01:28:11.039]                             }
[01:28:11.039]                             return(sendCondition)
[01:28:11.039]                           }
[01:28:11.039]                         }
[01:28:11.039]                         frame <- frame + 1L
[01:28:11.039]                         envir <- sys.frame(frame)
[01:28:11.039]                       }
[01:28:11.039]                     }
[01:28:11.039]                     sendCondition <<- function(cond) NULL
[01:28:11.039]                   }
[01:28:11.039]                 })
[01:28:11.039]                 withCallingHandlers({
[01:28:11.039]                   value(a) + 1
[01:28:11.039]                 }, immediateCondition = function(cond) {
[01:28:11.039]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.039]                   sendCondition(cond)
[01:28:11.039]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.039]                   {
[01:28:11.039]                     inherits <- base::inherits
[01:28:11.039]                     invokeRestart <- base::invokeRestart
[01:28:11.039]                     is.null <- base::is.null
[01:28:11.039]                     muffled <- FALSE
[01:28:11.039]                     if (inherits(cond, "message")) {
[01:28:11.039]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.039]                       if (muffled) 
[01:28:11.039]                         invokeRestart("muffleMessage")
[01:28:11.039]                     }
[01:28:11.039]                     else if (inherits(cond, "warning")) {
[01:28:11.039]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.039]                       if (muffled) 
[01:28:11.039]                         invokeRestart("muffleWarning")
[01:28:11.039]                     }
[01:28:11.039]                     else if (inherits(cond, "condition")) {
[01:28:11.039]                       if (!is.null(pattern)) {
[01:28:11.039]                         computeRestarts <- base::computeRestarts
[01:28:11.039]                         grepl <- base::grepl
[01:28:11.039]                         restarts <- computeRestarts(cond)
[01:28:11.039]                         for (restart in restarts) {
[01:28:11.039]                           name <- restart$name
[01:28:11.039]                           if (is.null(name)) 
[01:28:11.039]                             next
[01:28:11.039]                           if (!grepl(pattern, name)) 
[01:28:11.039]                             next
[01:28:11.039]                           invokeRestart(restart)
[01:28:11.039]                           muffled <- TRUE
[01:28:11.039]                           break
[01:28:11.039]                         }
[01:28:11.039]                       }
[01:28:11.039]                     }
[01:28:11.039]                     invisible(muffled)
[01:28:11.039]                   }
[01:28:11.039]                   muffleCondition(cond)
[01:28:11.039]                 })
[01:28:11.039]             }))
[01:28:11.039]             future::FutureResult(value = ...future.value$value, 
[01:28:11.039]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.039]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.039]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.039]                     ...future.globalenv.names))
[01:28:11.039]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.039]         }, condition = base::local({
[01:28:11.039]             c <- base::c
[01:28:11.039]             inherits <- base::inherits
[01:28:11.039]             invokeRestart <- base::invokeRestart
[01:28:11.039]             length <- base::length
[01:28:11.039]             list <- base::list
[01:28:11.039]             seq.int <- base::seq.int
[01:28:11.039]             signalCondition <- base::signalCondition
[01:28:11.039]             sys.calls <- base::sys.calls
[01:28:11.039]             `[[` <- base::`[[`
[01:28:11.039]             `+` <- base::`+`
[01:28:11.039]             `<<-` <- base::`<<-`
[01:28:11.039]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.039]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.039]                   3L)]
[01:28:11.039]             }
[01:28:11.039]             function(cond) {
[01:28:11.039]                 is_error <- inherits(cond, "error")
[01:28:11.039]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.039]                   NULL)
[01:28:11.039]                 if (is_error) {
[01:28:11.039]                   sessionInformation <- function() {
[01:28:11.039]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.039]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.039]                       search = base::search(), system = base::Sys.info())
[01:28:11.039]                   }
[01:28:11.039]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.039]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.039]                     cond$call), session = sessionInformation(), 
[01:28:11.039]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.039]                   signalCondition(cond)
[01:28:11.039]                 }
[01:28:11.039]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.039]                 "immediateCondition"))) {
[01:28:11.039]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.039]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.039]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.039]                   if (TRUE && !signal) {
[01:28:11.039]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.039]                     {
[01:28:11.039]                       inherits <- base::inherits
[01:28:11.039]                       invokeRestart <- base::invokeRestart
[01:28:11.039]                       is.null <- base::is.null
[01:28:11.039]                       muffled <- FALSE
[01:28:11.039]                       if (inherits(cond, "message")) {
[01:28:11.039]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.039]                         if (muffled) 
[01:28:11.039]                           invokeRestart("muffleMessage")
[01:28:11.039]                       }
[01:28:11.039]                       else if (inherits(cond, "warning")) {
[01:28:11.039]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.039]                         if (muffled) 
[01:28:11.039]                           invokeRestart("muffleWarning")
[01:28:11.039]                       }
[01:28:11.039]                       else if (inherits(cond, "condition")) {
[01:28:11.039]                         if (!is.null(pattern)) {
[01:28:11.039]                           computeRestarts <- base::computeRestarts
[01:28:11.039]                           grepl <- base::grepl
[01:28:11.039]                           restarts <- computeRestarts(cond)
[01:28:11.039]                           for (restart in restarts) {
[01:28:11.039]                             name <- restart$name
[01:28:11.039]                             if (is.null(name)) 
[01:28:11.039]                               next
[01:28:11.039]                             if (!grepl(pattern, name)) 
[01:28:11.039]                               next
[01:28:11.039]                             invokeRestart(restart)
[01:28:11.039]                             muffled <- TRUE
[01:28:11.039]                             break
[01:28:11.039]                           }
[01:28:11.039]                         }
[01:28:11.039]                       }
[01:28:11.039]                       invisible(muffled)
[01:28:11.039]                     }
[01:28:11.039]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.039]                   }
[01:28:11.039]                 }
[01:28:11.039]                 else {
[01:28:11.039]                   if (TRUE) {
[01:28:11.039]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.039]                     {
[01:28:11.039]                       inherits <- base::inherits
[01:28:11.039]                       invokeRestart <- base::invokeRestart
[01:28:11.039]                       is.null <- base::is.null
[01:28:11.039]                       muffled <- FALSE
[01:28:11.039]                       if (inherits(cond, "message")) {
[01:28:11.039]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.039]                         if (muffled) 
[01:28:11.039]                           invokeRestart("muffleMessage")
[01:28:11.039]                       }
[01:28:11.039]                       else if (inherits(cond, "warning")) {
[01:28:11.039]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.039]                         if (muffled) 
[01:28:11.039]                           invokeRestart("muffleWarning")
[01:28:11.039]                       }
[01:28:11.039]                       else if (inherits(cond, "condition")) {
[01:28:11.039]                         if (!is.null(pattern)) {
[01:28:11.039]                           computeRestarts <- base::computeRestarts
[01:28:11.039]                           grepl <- base::grepl
[01:28:11.039]                           restarts <- computeRestarts(cond)
[01:28:11.039]                           for (restart in restarts) {
[01:28:11.039]                             name <- restart$name
[01:28:11.039]                             if (is.null(name)) 
[01:28:11.039]                               next
[01:28:11.039]                             if (!grepl(pattern, name)) 
[01:28:11.039]                               next
[01:28:11.039]                             invokeRestart(restart)
[01:28:11.039]                             muffled <- TRUE
[01:28:11.039]                             break
[01:28:11.039]                           }
[01:28:11.039]                         }
[01:28:11.039]                       }
[01:28:11.039]                       invisible(muffled)
[01:28:11.039]                     }
[01:28:11.039]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.039]                   }
[01:28:11.039]                 }
[01:28:11.039]             }
[01:28:11.039]         }))
[01:28:11.039]     }, error = function(ex) {
[01:28:11.039]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.039]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.039]                 ...future.rng), started = ...future.startTime, 
[01:28:11.039]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.039]             version = "1.8"), class = "FutureResult")
[01:28:11.039]     }, finally = {
[01:28:11.039]         if (!identical(...future.workdir, getwd())) 
[01:28:11.039]             setwd(...future.workdir)
[01:28:11.039]         {
[01:28:11.039]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.039]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.039]             }
[01:28:11.039]             base::options(...future.oldOptions)
[01:28:11.039]             if (.Platform$OS.type == "windows") {
[01:28:11.039]                 old_names <- names(...future.oldEnvVars)
[01:28:11.039]                 envs <- base::Sys.getenv()
[01:28:11.039]                 names <- names(envs)
[01:28:11.039]                 common <- intersect(names, old_names)
[01:28:11.039]                 added <- setdiff(names, old_names)
[01:28:11.039]                 removed <- setdiff(old_names, names)
[01:28:11.039]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.039]                   envs[common]]
[01:28:11.039]                 NAMES <- toupper(changed)
[01:28:11.039]                 args <- list()
[01:28:11.039]                 for (kk in seq_along(NAMES)) {
[01:28:11.039]                   name <- changed[[kk]]
[01:28:11.039]                   NAME <- NAMES[[kk]]
[01:28:11.039]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.039]                     next
[01:28:11.039]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.039]                 }
[01:28:11.039]                 NAMES <- toupper(added)
[01:28:11.039]                 for (kk in seq_along(NAMES)) {
[01:28:11.039]                   name <- added[[kk]]
[01:28:11.039]                   NAME <- NAMES[[kk]]
[01:28:11.039]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.039]                     next
[01:28:11.039]                   args[[name]] <- ""
[01:28:11.039]                 }
[01:28:11.039]                 NAMES <- toupper(removed)
[01:28:11.039]                 for (kk in seq_along(NAMES)) {
[01:28:11.039]                   name <- removed[[kk]]
[01:28:11.039]                   NAME <- NAMES[[kk]]
[01:28:11.039]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.039]                     next
[01:28:11.039]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.039]                 }
[01:28:11.039]                 if (length(args) > 0) 
[01:28:11.039]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.039]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.039]             }
[01:28:11.039]             else {
[01:28:11.039]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.039]             }
[01:28:11.039]             {
[01:28:11.039]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.039]                   0L) {
[01:28:11.039]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.039]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.039]                   base::options(opts)
[01:28:11.039]                 }
[01:28:11.039]                 {
[01:28:11.039]                   {
[01:28:11.039]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.039]                     NULL
[01:28:11.039]                   }
[01:28:11.039]                   options(future.plan = NULL)
[01:28:11.039]                   if (is.na(NA_character_)) 
[01:28:11.039]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.039]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.039]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.039]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.039]                     envir = parent.frame()) 
[01:28:11.039]                   {
[01:28:11.039]                     if (is.function(workers)) 
[01:28:11.039]                       workers <- workers()
[01:28:11.039]                     workers <- structure(as.integer(workers), 
[01:28:11.039]                       class = class(workers))
[01:28:11.039]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.039]                       workers >= 1)
[01:28:11.039]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.039]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.039]                     }
[01:28:11.039]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.039]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.039]                       envir = envir)
[01:28:11.039]                     if (!future$lazy) 
[01:28:11.039]                       future <- run(future)
[01:28:11.039]                     invisible(future)
[01:28:11.039]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.039]                 }
[01:28:11.039]             }
[01:28:11.039]         }
[01:28:11.039]     })
[01:28:11.039]     if (TRUE) {
[01:28:11.039]         base::sink(type = "output", split = FALSE)
[01:28:11.039]         if (TRUE) {
[01:28:11.039]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.039]         }
[01:28:11.039]         else {
[01:28:11.039]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.039]         }
[01:28:11.039]         base::close(...future.stdout)
[01:28:11.039]         ...future.stdout <- NULL
[01:28:11.039]     }
[01:28:11.039]     ...future.result$conditions <- ...future.conditions
[01:28:11.039]     ...future.result$finished <- base::Sys.time()
[01:28:11.039]     ...future.result
[01:28:11.039] }
[01:28:11.044] Exporting 1 global objects (1.59 MiB) to cluster node #1 ...
[01:28:11.047] Exporting 'a' (1.59 MiB) to cluster node #1 ...
[01:28:11.058] Exporting 'a' (1.59 MiB) to cluster node #1 ... DONE
[01:28:11.059] Exporting 1 global objects (1.59 MiB) to cluster node #1 ... DONE
[01:28:11.059] MultisessionFuture started
[01:28:11.059] - Launch lazy future ... done
[01:28:11.060] run() for 'MultisessionFuture' ... done
[01:28:11.060] result() for ClusterFuture ...
[01:28:11.060] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.060] - Validating connection of MultisessionFuture
[01:28:11.078] - received message: FutureResult
[01:28:11.079] - Received FutureResult
[01:28:11.079] - Erased future from FutureRegistry
[01:28:11.079] result() for ClusterFuture ...
[01:28:11.079] - result already collected: FutureResult
[01:28:11.079] result() for ClusterFuture ... done
[01:28:11.080] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.080] result() for ClusterFuture ... done
[01:28:11.080] result() for ClusterFuture ...
[01:28:11.080] - result already collected: FutureResult
[01:28:11.080] result() for ClusterFuture ... done
value(b) = 2
[01:28:11.081] result() for ClusterFuture ...
[01:28:11.081] - result already collected: FutureResult
[01:28:11.081] result() for ClusterFuture ... done
[01:28:11.081] result() for ClusterFuture ...
[01:28:11.081] - result already collected: FutureResult
[01:28:11.081] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.082] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.082] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.083] 
[01:28:11.083] Searching for globals ... DONE
[01:28:11.083] - globals: [0] <none>
[01:28:11.083] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.084] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.084] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.085] - globals found: [3] '+', 'value', 'a'
[01:28:11.085] Searching for globals ... DONE
[01:28:11.085] Resolving globals: TRUE
[01:28:11.086] Resolving any globals that are futures ...
[01:28:11.086] - globals: [3] '+', 'value', 'a'
[01:28:11.086] Resolving any globals that are futures ... DONE
[01:28:11.086] Resolving futures part of globals (recursively) ...
[01:28:11.087] resolve() on list ...
[01:28:11.087]  recursive: 99
[01:28:11.087]  length: 1
[01:28:11.087]  elements: 'a'
[01:28:11.087] run() for 'Future' ...
[01:28:11.088] - state: 'created'
[01:28:11.088] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.104] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.104] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.105]   - Field: 'node'
[01:28:11.105]   - Field: 'label'
[01:28:11.105]   - Field: 'local'
[01:28:11.106]   - Field: 'owner'
[01:28:11.106]   - Field: 'envir'
[01:28:11.106]   - Field: 'workers'
[01:28:11.107]   - Field: 'packages'
[01:28:11.107]   - Field: 'gc'
[01:28:11.107]   - Field: 'conditions'
[01:28:11.108]   - Field: 'persistent'
[01:28:11.108]   - Field: 'expr'
[01:28:11.108]   - Field: 'uuid'
[01:28:11.109]   - Field: 'seed'
[01:28:11.109]   - Field: 'version'
[01:28:11.110]   - Field: 'result'
[01:28:11.110]   - Field: 'asynchronous'
[01:28:11.110]   - Field: 'calls'
[01:28:11.111]   - Field: 'globals'
[01:28:11.111]   - Field: 'stdout'
[01:28:11.111]   - Field: 'earlySignal'
[01:28:11.112]   - Field: 'lazy'
[01:28:11.112]   - Field: 'state'
[01:28:11.112] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.113] - Launch lazy future ...
[01:28:11.113] Packages needed by the future expression (n = 0): <none>
[01:28:11.113] Packages needed by future strategies (n = 0): <none>
[01:28:11.114] {
[01:28:11.114]     {
[01:28:11.114]         {
[01:28:11.114]             ...future.startTime <- base::Sys.time()
[01:28:11.114]             {
[01:28:11.114]                 {
[01:28:11.114]                   {
[01:28:11.114]                     {
[01:28:11.114]                       base::local({
[01:28:11.114]                         has_future <- base::requireNamespace("future", 
[01:28:11.114]                           quietly = TRUE)
[01:28:11.114]                         if (has_future) {
[01:28:11.114]                           ns <- base::getNamespace("future")
[01:28:11.114]                           version <- ns[[".package"]][["version"]]
[01:28:11.114]                           if (is.null(version)) 
[01:28:11.114]                             version <- utils::packageVersion("future")
[01:28:11.114]                         }
[01:28:11.114]                         else {
[01:28:11.114]                           version <- NULL
[01:28:11.114]                         }
[01:28:11.114]                         if (!has_future || version < "1.8.0") {
[01:28:11.114]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.114]                             "", base::R.version$version.string), 
[01:28:11.114]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:11.114]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:11.114]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.114]                               "release", "version")], collapse = " "), 
[01:28:11.114]                             hostname = base::Sys.info()[["nodename"]])
[01:28:11.114]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.114]                             info)
[01:28:11.114]                           info <- base::paste(info, collapse = "; ")
[01:28:11.114]                           if (!has_future) {
[01:28:11.114]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.114]                               info)
[01:28:11.114]                           }
[01:28:11.114]                           else {
[01:28:11.114]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.114]                               info, version)
[01:28:11.114]                           }
[01:28:11.114]                           base::stop(msg)
[01:28:11.114]                         }
[01:28:11.114]                       })
[01:28:11.114]                     }
[01:28:11.114]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.114]                     base::options(mc.cores = 1L)
[01:28:11.114]                   }
[01:28:11.114]                   options(future.plan = NULL)
[01:28:11.114]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.114]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.114]                 }
[01:28:11.114]                 ...future.workdir <- getwd()
[01:28:11.114]             }
[01:28:11.114]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.114]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.114]         }
[01:28:11.114]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.114]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.114]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.114]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.114]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.114]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.114]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.114]             base::names(...future.oldOptions))
[01:28:11.114]     }
[01:28:11.114]     if (FALSE) {
[01:28:11.114]     }
[01:28:11.114]     else {
[01:28:11.114]         if (TRUE) {
[01:28:11.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.114]                 open = "w")
[01:28:11.114]         }
[01:28:11.114]         else {
[01:28:11.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.114]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.114]         }
[01:28:11.114]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.114]             base::sink(type = "output", split = FALSE)
[01:28:11.114]             base::close(...future.stdout)
[01:28:11.114]         }, add = TRUE)
[01:28:11.114]     }
[01:28:11.114]     ...future.frame <- base::sys.nframe()
[01:28:11.114]     ...future.conditions <- base::list()
[01:28:11.114]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.114]     if (FALSE) {
[01:28:11.114]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.114]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.114]     }
[01:28:11.114]     ...future.result <- base::tryCatch({
[01:28:11.114]         base::withCallingHandlers({
[01:28:11.114]             ...future.value <- base::withVisible(base::local({
[01:28:11.114]                 ...future.makeSendCondition <- base::local({
[01:28:11.114]                   sendCondition <- NULL
[01:28:11.114]                   function(frame = 1L) {
[01:28:11.114]                     if (is.function(sendCondition)) 
[01:28:11.114]                       return(sendCondition)
[01:28:11.114]                     ns <- getNamespace("parallel")
[01:28:11.114]                     if (exists("sendData", mode = "function", 
[01:28:11.114]                       envir = ns)) {
[01:28:11.114]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.114]                         envir = ns)
[01:28:11.114]                       envir <- sys.frame(frame)
[01:28:11.114]                       master <- NULL
[01:28:11.114]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.114]                         !identical(envir, emptyenv())) {
[01:28:11.114]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.114]                           inherits = FALSE)) {
[01:28:11.114]                           master <- get("master", mode = "list", 
[01:28:11.114]                             envir = envir, inherits = FALSE)
[01:28:11.114]                           if (inherits(master, c("SOCKnode", 
[01:28:11.114]                             "SOCK0node"))) {
[01:28:11.114]                             sendCondition <<- function(cond) {
[01:28:11.114]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.114]                                 success = TRUE)
[01:28:11.114]                               parallel_sendData(master, data)
[01:28:11.114]                             }
[01:28:11.114]                             return(sendCondition)
[01:28:11.114]                           }
[01:28:11.114]                         }
[01:28:11.114]                         frame <- frame + 1L
[01:28:11.114]                         envir <- sys.frame(frame)
[01:28:11.114]                       }
[01:28:11.114]                     }
[01:28:11.114]                     sendCondition <<- function(cond) NULL
[01:28:11.114]                   }
[01:28:11.114]                 })
[01:28:11.114]                 withCallingHandlers({
[01:28:11.114]                   1
[01:28:11.114]                 }, immediateCondition = function(cond) {
[01:28:11.114]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.114]                   sendCondition(cond)
[01:28:11.114]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.114]                   {
[01:28:11.114]                     inherits <- base::inherits
[01:28:11.114]                     invokeRestart <- base::invokeRestart
[01:28:11.114]                     is.null <- base::is.null
[01:28:11.114]                     muffled <- FALSE
[01:28:11.114]                     if (inherits(cond, "message")) {
[01:28:11.114]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.114]                       if (muffled) 
[01:28:11.114]                         invokeRestart("muffleMessage")
[01:28:11.114]                     }
[01:28:11.114]                     else if (inherits(cond, "warning")) {
[01:28:11.114]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.114]                       if (muffled) 
[01:28:11.114]                         invokeRestart("muffleWarning")
[01:28:11.114]                     }
[01:28:11.114]                     else if (inherits(cond, "condition")) {
[01:28:11.114]                       if (!is.null(pattern)) {
[01:28:11.114]                         computeRestarts <- base::computeRestarts
[01:28:11.114]                         grepl <- base::grepl
[01:28:11.114]                         restarts <- computeRestarts(cond)
[01:28:11.114]                         for (restart in restarts) {
[01:28:11.114]                           name <- restart$name
[01:28:11.114]                           if (is.null(name)) 
[01:28:11.114]                             next
[01:28:11.114]                           if (!grepl(pattern, name)) 
[01:28:11.114]                             next
[01:28:11.114]                           invokeRestart(restart)
[01:28:11.114]                           muffled <- TRUE
[01:28:11.114]                           break
[01:28:11.114]                         }
[01:28:11.114]                       }
[01:28:11.114]                     }
[01:28:11.114]                     invisible(muffled)
[01:28:11.114]                   }
[01:28:11.114]                   muffleCondition(cond)
[01:28:11.114]                 })
[01:28:11.114]             }))
[01:28:11.114]             future::FutureResult(value = ...future.value$value, 
[01:28:11.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.114]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.114]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.114]                     ...future.globalenv.names))
[01:28:11.114]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.114]         }, condition = base::local({
[01:28:11.114]             c <- base::c
[01:28:11.114]             inherits <- base::inherits
[01:28:11.114]             invokeRestart <- base::invokeRestart
[01:28:11.114]             length <- base::length
[01:28:11.114]             list <- base::list
[01:28:11.114]             seq.int <- base::seq.int
[01:28:11.114]             signalCondition <- base::signalCondition
[01:28:11.114]             sys.calls <- base::sys.calls
[01:28:11.114]             `[[` <- base::`[[`
[01:28:11.114]             `+` <- base::`+`
[01:28:11.114]             `<<-` <- base::`<<-`
[01:28:11.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.114]                   3L)]
[01:28:11.114]             }
[01:28:11.114]             function(cond) {
[01:28:11.114]                 is_error <- inherits(cond, "error")
[01:28:11.114]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.114]                   NULL)
[01:28:11.114]                 if (is_error) {
[01:28:11.114]                   sessionInformation <- function() {
[01:28:11.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.114]                       search = base::search(), system = base::Sys.info())
[01:28:11.114]                   }
[01:28:11.114]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.114]                     cond$call), session = sessionInformation(), 
[01:28:11.114]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.114]                   signalCondition(cond)
[01:28:11.114]                 }
[01:28:11.114]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.114]                 "immediateCondition"))) {
[01:28:11.114]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.114]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.114]                   if (TRUE && !signal) {
[01:28:11.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.114]                     {
[01:28:11.114]                       inherits <- base::inherits
[01:28:11.114]                       invokeRestart <- base::invokeRestart
[01:28:11.114]                       is.null <- base::is.null
[01:28:11.114]                       muffled <- FALSE
[01:28:11.114]                       if (inherits(cond, "message")) {
[01:28:11.114]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.114]                         if (muffled) 
[01:28:11.114]                           invokeRestart("muffleMessage")
[01:28:11.114]                       }
[01:28:11.114]                       else if (inherits(cond, "warning")) {
[01:28:11.114]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.114]                         if (muffled) 
[01:28:11.114]                           invokeRestart("muffleWarning")
[01:28:11.114]                       }
[01:28:11.114]                       else if (inherits(cond, "condition")) {
[01:28:11.114]                         if (!is.null(pattern)) {
[01:28:11.114]                           computeRestarts <- base::computeRestarts
[01:28:11.114]                           grepl <- base::grepl
[01:28:11.114]                           restarts <- computeRestarts(cond)
[01:28:11.114]                           for (restart in restarts) {
[01:28:11.114]                             name <- restart$name
[01:28:11.114]                             if (is.null(name)) 
[01:28:11.114]                               next
[01:28:11.114]                             if (!grepl(pattern, name)) 
[01:28:11.114]                               next
[01:28:11.114]                             invokeRestart(restart)
[01:28:11.114]                             muffled <- TRUE
[01:28:11.114]                             break
[01:28:11.114]                           }
[01:28:11.114]                         }
[01:28:11.114]                       }
[01:28:11.114]                       invisible(muffled)
[01:28:11.114]                     }
[01:28:11.114]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.114]                   }
[01:28:11.114]                 }
[01:28:11.114]                 else {
[01:28:11.114]                   if (TRUE) {
[01:28:11.114]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.114]                     {
[01:28:11.114]                       inherits <- base::inherits
[01:28:11.114]                       invokeRestart <- base::invokeRestart
[01:28:11.114]                       is.null <- base::is.null
[01:28:11.114]                       muffled <- FALSE
[01:28:11.114]                       if (inherits(cond, "message")) {
[01:28:11.114]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.114]                         if (muffled) 
[01:28:11.114]                           invokeRestart("muffleMessage")
[01:28:11.114]                       }
[01:28:11.114]                       else if (inherits(cond, "warning")) {
[01:28:11.114]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.114]                         if (muffled) 
[01:28:11.114]                           invokeRestart("muffleWarning")
[01:28:11.114]                       }
[01:28:11.114]                       else if (inherits(cond, "condition")) {
[01:28:11.114]                         if (!is.null(pattern)) {
[01:28:11.114]                           computeRestarts <- base::computeRestarts
[01:28:11.114]                           grepl <- base::grepl
[01:28:11.114]                           restarts <- computeRestarts(cond)
[01:28:11.114]                           for (restart in restarts) {
[01:28:11.114]                             name <- restart$name
[01:28:11.114]                             if (is.null(name)) 
[01:28:11.114]                               next
[01:28:11.114]                             if (!grepl(pattern, name)) 
[01:28:11.114]                               next
[01:28:11.114]                             invokeRestart(restart)
[01:28:11.114]                             muffled <- TRUE
[01:28:11.114]                             break
[01:28:11.114]                           }
[01:28:11.114]                         }
[01:28:11.114]                       }
[01:28:11.114]                       invisible(muffled)
[01:28:11.114]                     }
[01:28:11.114]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.114]                   }
[01:28:11.114]                 }
[01:28:11.114]             }
[01:28:11.114]         }))
[01:28:11.114]     }, error = function(ex) {
[01:28:11.114]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.114]                 ...future.rng), started = ...future.startTime, 
[01:28:11.114]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.114]             version = "1.8"), class = "FutureResult")
[01:28:11.114]     }, finally = {
[01:28:11.114]         if (!identical(...future.workdir, getwd())) 
[01:28:11.114]             setwd(...future.workdir)
[01:28:11.114]         {
[01:28:11.114]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.114]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.114]             }
[01:28:11.114]             base::options(...future.oldOptions)
[01:28:11.114]             if (.Platform$OS.type == "windows") {
[01:28:11.114]                 old_names <- names(...future.oldEnvVars)
[01:28:11.114]                 envs <- base::Sys.getenv()
[01:28:11.114]                 names <- names(envs)
[01:28:11.114]                 common <- intersect(names, old_names)
[01:28:11.114]                 added <- setdiff(names, old_names)
[01:28:11.114]                 removed <- setdiff(old_names, names)
[01:28:11.114]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.114]                   envs[common]]
[01:28:11.114]                 NAMES <- toupper(changed)
[01:28:11.114]                 args <- list()
[01:28:11.114]                 for (kk in seq_along(NAMES)) {
[01:28:11.114]                   name <- changed[[kk]]
[01:28:11.114]                   NAME <- NAMES[[kk]]
[01:28:11.114]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.114]                     next
[01:28:11.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.114]                 }
[01:28:11.114]                 NAMES <- toupper(added)
[01:28:11.114]                 for (kk in seq_along(NAMES)) {
[01:28:11.114]                   name <- added[[kk]]
[01:28:11.114]                   NAME <- NAMES[[kk]]
[01:28:11.114]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.114]                     next
[01:28:11.114]                   args[[name]] <- ""
[01:28:11.114]                 }
[01:28:11.114]                 NAMES <- toupper(removed)
[01:28:11.114]                 for (kk in seq_along(NAMES)) {
[01:28:11.114]                   name <- removed[[kk]]
[01:28:11.114]                   NAME <- NAMES[[kk]]
[01:28:11.114]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.114]                     next
[01:28:11.114]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.114]                 }
[01:28:11.114]                 if (length(args) > 0) 
[01:28:11.114]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.114]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.114]             }
[01:28:11.114]             else {
[01:28:11.114]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.114]             }
[01:28:11.114]             {
[01:28:11.114]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.114]                   0L) {
[01:28:11.114]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.114]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.114]                   base::options(opts)
[01:28:11.114]                 }
[01:28:11.114]                 {
[01:28:11.114]                   {
[01:28:11.114]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.114]                     NULL
[01:28:11.114]                   }
[01:28:11.114]                   options(future.plan = NULL)
[01:28:11.114]                   if (is.na(NA_character_)) 
[01:28:11.114]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.114]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.114]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.114]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.114]                     envir = parent.frame()) 
[01:28:11.114]                   {
[01:28:11.114]                     if (is.function(workers)) 
[01:28:11.114]                       workers <- workers()
[01:28:11.114]                     workers <- structure(as.integer(workers), 
[01:28:11.114]                       class = class(workers))
[01:28:11.114]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.114]                       workers >= 1)
[01:28:11.114]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.114]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.114]                     }
[01:28:11.114]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.114]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.114]                       envir = envir)
[01:28:11.114]                     if (!future$lazy) 
[01:28:11.114]                       future <- run(future)
[01:28:11.114]                     invisible(future)
[01:28:11.114]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.114]                 }
[01:28:11.114]             }
[01:28:11.114]         }
[01:28:11.114]     })
[01:28:11.114]     if (TRUE) {
[01:28:11.114]         base::sink(type = "output", split = FALSE)
[01:28:11.114]         if (TRUE) {
[01:28:11.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.114]         }
[01:28:11.114]         else {
[01:28:11.114]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.114]         }
[01:28:11.114]         base::close(...future.stdout)
[01:28:11.114]         ...future.stdout <- NULL
[01:28:11.114]     }
[01:28:11.114]     ...future.result$conditions <- ...future.conditions
[01:28:11.114]     ...future.result$finished <- base::Sys.time()
[01:28:11.114]     ...future.result
[01:28:11.114] }
[01:28:11.120] MultisessionFuture started
[01:28:11.120] - Launch lazy future ... done
[01:28:11.120] run() for 'MultisessionFuture' ... done
[01:28:11.136] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.136] - Validating connection of MultisessionFuture
[01:28:11.137] - received message: FutureResult
[01:28:11.137] - Received FutureResult
[01:28:11.137] - Erased future from FutureRegistry
[01:28:11.137] result() for ClusterFuture ...
[01:28:11.137] - result already collected: FutureResult
[01:28:11.138] result() for ClusterFuture ... done
[01:28:11.138] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.138] Future #1
[01:28:11.138] result() for ClusterFuture ...
[01:28:11.138] - result already collected: FutureResult
[01:28:11.138] result() for ClusterFuture ... done
[01:28:11.139] result() for ClusterFuture ...
[01:28:11.139] - result already collected: FutureResult
[01:28:11.139] result() for ClusterFuture ... done
[01:28:11.139] A MultisessionFuture was resolved
[01:28:11.139]  length: 0 (resolved future 1)
[01:28:11.139] resolve() on list ... DONE
[01:28:11.140] - globals: [1] 'a'
[01:28:11.140] Resolving futures part of globals (recursively) ... DONE
[01:28:11.142] The total size of the 1 globals is 1.59 MiB (1663240 bytes)
[01:28:11.143] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.59 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.59 MiB of class 'environment')
[01:28:11.143] - globals: [1] 'a'
[01:28:11.143] - packages: [1] 'future'
[01:28:11.144] getGlobalsAndPackages() ... DONE
[01:28:11.144] run() for 'Future' ...
[01:28:11.144] - state: 'created'
[01:28:11.144] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.162] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.162] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.163]   - Field: 'node'
[01:28:11.163]   - Field: 'label'
[01:28:11.163]   - Field: 'local'
[01:28:11.163]   - Field: 'owner'
[01:28:11.164]   - Field: 'envir'
[01:28:11.164]   - Field: 'workers'
[01:28:11.164]   - Field: 'packages'
[01:28:11.164]   - Field: 'gc'
[01:28:11.165]   - Field: 'conditions'
[01:28:11.165]   - Field: 'persistent'
[01:28:11.165]   - Field: 'expr'
[01:28:11.165]   - Field: 'uuid'
[01:28:11.166]   - Field: 'seed'
[01:28:11.166]   - Field: 'version'
[01:28:11.166]   - Field: 'result'
[01:28:11.166]   - Field: 'asynchronous'
[01:28:11.167]   - Field: 'calls'
[01:28:11.167]   - Field: 'globals'
[01:28:11.167]   - Field: 'stdout'
[01:28:11.167]   - Field: 'earlySignal'
[01:28:11.168]   - Field: 'lazy'
[01:28:11.168]   - Field: 'state'
[01:28:11.168] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.168] - Launch lazy future ...
[01:28:11.169] Packages needed by the future expression (n = 1): 'future'
[01:28:11.169] Packages needed by future strategies (n = 0): <none>
[01:28:11.169] {
[01:28:11.169]     {
[01:28:11.169]         {
[01:28:11.169]             ...future.startTime <- base::Sys.time()
[01:28:11.169]             {
[01:28:11.169]                 {
[01:28:11.169]                   {
[01:28:11.169]                     {
[01:28:11.169]                       {
[01:28:11.169]                         base::local({
[01:28:11.169]                           has_future <- base::requireNamespace("future", 
[01:28:11.169]                             quietly = TRUE)
[01:28:11.169]                           if (has_future) {
[01:28:11.169]                             ns <- base::getNamespace("future")
[01:28:11.169]                             version <- ns[[".package"]][["version"]]
[01:28:11.169]                             if (is.null(version)) 
[01:28:11.169]                               version <- utils::packageVersion("future")
[01:28:11.169]                           }
[01:28:11.169]                           else {
[01:28:11.169]                             version <- NULL
[01:28:11.169]                           }
[01:28:11.169]                           if (!has_future || version < "1.8.0") {
[01:28:11.169]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.169]                               "", base::R.version$version.string), 
[01:28:11.169]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:11.169]                                 base::R.version$platform, 8 * 
[01:28:11.169]                                   base::.Machine$sizeof.pointer), 
[01:28:11.169]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.169]                                 "release", "version")], collapse = " "), 
[01:28:11.169]                               hostname = base::Sys.info()[["nodename"]])
[01:28:11.169]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.169]                               info)
[01:28:11.169]                             info <- base::paste(info, collapse = "; ")
[01:28:11.169]                             if (!has_future) {
[01:28:11.169]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.169]                                 info)
[01:28:11.169]                             }
[01:28:11.169]                             else {
[01:28:11.169]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.169]                                 info, version)
[01:28:11.169]                             }
[01:28:11.169]                             base::stop(msg)
[01:28:11.169]                           }
[01:28:11.169]                         })
[01:28:11.169]                       }
[01:28:11.169]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.169]                       base::options(mc.cores = 1L)
[01:28:11.169]                     }
[01:28:11.169]                     base::local({
[01:28:11.169]                       for (pkg in "future") {
[01:28:11.169]                         base::loadNamespace(pkg)
[01:28:11.169]                         base::library(pkg, character.only = TRUE)
[01:28:11.169]                       }
[01:28:11.169]                     })
[01:28:11.169]                   }
[01:28:11.169]                   options(future.plan = NULL)
[01:28:11.169]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.169]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.169]                 }
[01:28:11.169]                 ...future.workdir <- getwd()
[01:28:11.169]             }
[01:28:11.169]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.169]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.169]         }
[01:28:11.169]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.169]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.169]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.169]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.169]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.169]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.169]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.169]             base::names(...future.oldOptions))
[01:28:11.169]     }
[01:28:11.169]     if (FALSE) {
[01:28:11.169]     }
[01:28:11.169]     else {
[01:28:11.169]         if (TRUE) {
[01:28:11.169]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.169]                 open = "w")
[01:28:11.169]         }
[01:28:11.169]         else {
[01:28:11.169]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.169]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.169]         }
[01:28:11.169]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.169]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.169]             base::sink(type = "output", split = FALSE)
[01:28:11.169]             base::close(...future.stdout)
[01:28:11.169]         }, add = TRUE)
[01:28:11.169]     }
[01:28:11.169]     ...future.frame <- base::sys.nframe()
[01:28:11.169]     ...future.conditions <- base::list()
[01:28:11.169]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.169]     if (FALSE) {
[01:28:11.169]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.169]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.169]     }
[01:28:11.169]     ...future.result <- base::tryCatch({
[01:28:11.169]         base::withCallingHandlers({
[01:28:11.169]             ...future.value <- base::withVisible(base::local({
[01:28:11.169]                 ...future.makeSendCondition <- base::local({
[01:28:11.169]                   sendCondition <- NULL
[01:28:11.169]                   function(frame = 1L) {
[01:28:11.169]                     if (is.function(sendCondition)) 
[01:28:11.169]                       return(sendCondition)
[01:28:11.169]                     ns <- getNamespace("parallel")
[01:28:11.169]                     if (exists("sendData", mode = "function", 
[01:28:11.169]                       envir = ns)) {
[01:28:11.169]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.169]                         envir = ns)
[01:28:11.169]                       envir <- sys.frame(frame)
[01:28:11.169]                       master <- NULL
[01:28:11.169]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.169]                         !identical(envir, emptyenv())) {
[01:28:11.169]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.169]                           inherits = FALSE)) {
[01:28:11.169]                           master <- get("master", mode = "list", 
[01:28:11.169]                             envir = envir, inherits = FALSE)
[01:28:11.169]                           if (inherits(master, c("SOCKnode", 
[01:28:11.169]                             "SOCK0node"))) {
[01:28:11.169]                             sendCondition <<- function(cond) {
[01:28:11.169]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.169]                                 success = TRUE)
[01:28:11.169]                               parallel_sendData(master, data)
[01:28:11.169]                             }
[01:28:11.169]                             return(sendCondition)
[01:28:11.169]                           }
[01:28:11.169]                         }
[01:28:11.169]                         frame <- frame + 1L
[01:28:11.169]                         envir <- sys.frame(frame)
[01:28:11.169]                       }
[01:28:11.169]                     }
[01:28:11.169]                     sendCondition <<- function(cond) NULL
[01:28:11.169]                   }
[01:28:11.169]                 })
[01:28:11.169]                 withCallingHandlers({
[01:28:11.169]                   value(a) + 1
[01:28:11.169]                 }, immediateCondition = function(cond) {
[01:28:11.169]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.169]                   sendCondition(cond)
[01:28:11.169]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.169]                   {
[01:28:11.169]                     inherits <- base::inherits
[01:28:11.169]                     invokeRestart <- base::invokeRestart
[01:28:11.169]                     is.null <- base::is.null
[01:28:11.169]                     muffled <- FALSE
[01:28:11.169]                     if (inherits(cond, "message")) {
[01:28:11.169]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.169]                       if (muffled) 
[01:28:11.169]                         invokeRestart("muffleMessage")
[01:28:11.169]                     }
[01:28:11.169]                     else if (inherits(cond, "warning")) {
[01:28:11.169]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.169]                       if (muffled) 
[01:28:11.169]                         invokeRestart("muffleWarning")
[01:28:11.169]                     }
[01:28:11.169]                     else if (inherits(cond, "condition")) {
[01:28:11.169]                       if (!is.null(pattern)) {
[01:28:11.169]                         computeRestarts <- base::computeRestarts
[01:28:11.169]                         grepl <- base::grepl
[01:28:11.169]                         restarts <- computeRestarts(cond)
[01:28:11.169]                         for (restart in restarts) {
[01:28:11.169]                           name <- restart$name
[01:28:11.169]                           if (is.null(name)) 
[01:28:11.169]                             next
[01:28:11.169]                           if (!grepl(pattern, name)) 
[01:28:11.169]                             next
[01:28:11.169]                           invokeRestart(restart)
[01:28:11.169]                           muffled <- TRUE
[01:28:11.169]                           break
[01:28:11.169]                         }
[01:28:11.169]                       }
[01:28:11.169]                     }
[01:28:11.169]                     invisible(muffled)
[01:28:11.169]                   }
[01:28:11.169]                   muffleCondition(cond)
[01:28:11.169]                 })
[01:28:11.169]             }))
[01:28:11.169]             future::FutureResult(value = ...future.value$value, 
[01:28:11.169]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.169]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.169]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.169]                     ...future.globalenv.names))
[01:28:11.169]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.169]         }, condition = base::local({
[01:28:11.169]             c <- base::c
[01:28:11.169]             inherits <- base::inherits
[01:28:11.169]             invokeRestart <- base::invokeRestart
[01:28:11.169]             length <- base::length
[01:28:11.169]             list <- base::list
[01:28:11.169]             seq.int <- base::seq.int
[01:28:11.169]             signalCondition <- base::signalCondition
[01:28:11.169]             sys.calls <- base::sys.calls
[01:28:11.169]             `[[` <- base::`[[`
[01:28:11.169]             `+` <- base::`+`
[01:28:11.169]             `<<-` <- base::`<<-`
[01:28:11.169]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.169]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.169]                   3L)]
[01:28:11.169]             }
[01:28:11.169]             function(cond) {
[01:28:11.169]                 is_error <- inherits(cond, "error")
[01:28:11.169]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.169]                   NULL)
[01:28:11.169]                 if (is_error) {
[01:28:11.169]                   sessionInformation <- function() {
[01:28:11.169]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.169]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.169]                       search = base::search(), system = base::Sys.info())
[01:28:11.169]                   }
[01:28:11.169]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.169]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.169]                     cond$call), session = sessionInformation(), 
[01:28:11.169]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.169]                   signalCondition(cond)
[01:28:11.169]                 }
[01:28:11.169]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.169]                 "immediateCondition"))) {
[01:28:11.169]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.169]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.169]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.169]                   if (TRUE && !signal) {
[01:28:11.169]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.169]                     {
[01:28:11.169]                       inherits <- base::inherits
[01:28:11.169]                       invokeRestart <- base::invokeRestart
[01:28:11.169]                       is.null <- base::is.null
[01:28:11.169]                       muffled <- FALSE
[01:28:11.169]                       if (inherits(cond, "message")) {
[01:28:11.169]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.169]                         if (muffled) 
[01:28:11.169]                           invokeRestart("muffleMessage")
[01:28:11.169]                       }
[01:28:11.169]                       else if (inherits(cond, "warning")) {
[01:28:11.169]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.169]                         if (muffled) 
[01:28:11.169]                           invokeRestart("muffleWarning")
[01:28:11.169]                       }
[01:28:11.169]                       else if (inherits(cond, "condition")) {
[01:28:11.169]                         if (!is.null(pattern)) {
[01:28:11.169]                           computeRestarts <- base::computeRestarts
[01:28:11.169]                           grepl <- base::grepl
[01:28:11.169]                           restarts <- computeRestarts(cond)
[01:28:11.169]                           for (restart in restarts) {
[01:28:11.169]                             name <- restart$name
[01:28:11.169]                             if (is.null(name)) 
[01:28:11.169]                               next
[01:28:11.169]                             if (!grepl(pattern, name)) 
[01:28:11.169]                               next
[01:28:11.169]                             invokeRestart(restart)
[01:28:11.169]                             muffled <- TRUE
[01:28:11.169]                             break
[01:28:11.169]                           }
[01:28:11.169]                         }
[01:28:11.169]                       }
[01:28:11.169]                       invisible(muffled)
[01:28:11.169]                     }
[01:28:11.169]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.169]                   }
[01:28:11.169]                 }
[01:28:11.169]                 else {
[01:28:11.169]                   if (TRUE) {
[01:28:11.169]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.169]                     {
[01:28:11.169]                       inherits <- base::inherits
[01:28:11.169]                       invokeRestart <- base::invokeRestart
[01:28:11.169]                       is.null <- base::is.null
[01:28:11.169]                       muffled <- FALSE
[01:28:11.169]                       if (inherits(cond, "message")) {
[01:28:11.169]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.169]                         if (muffled) 
[01:28:11.169]                           invokeRestart("muffleMessage")
[01:28:11.169]                       }
[01:28:11.169]                       else if (inherits(cond, "warning")) {
[01:28:11.169]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.169]                         if (muffled) 
[01:28:11.169]                           invokeRestart("muffleWarning")
[01:28:11.169]                       }
[01:28:11.169]                       else if (inherits(cond, "condition")) {
[01:28:11.169]                         if (!is.null(pattern)) {
[01:28:11.169]                           computeRestarts <- base::computeRestarts
[01:28:11.169]                           grepl <- base::grepl
[01:28:11.169]                           restarts <- computeRestarts(cond)
[01:28:11.169]                           for (restart in restarts) {
[01:28:11.169]                             name <- restart$name
[01:28:11.169]                             if (is.null(name)) 
[01:28:11.169]                               next
[01:28:11.169]                             if (!grepl(pattern, name)) 
[01:28:11.169]                               next
[01:28:11.169]                             invokeRestart(restart)
[01:28:11.169]                             muffled <- TRUE
[01:28:11.169]                             break
[01:28:11.169]                           }
[01:28:11.169]                         }
[01:28:11.169]                       }
[01:28:11.169]                       invisible(muffled)
[01:28:11.169]                     }
[01:28:11.169]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.169]                   }
[01:28:11.169]                 }
[01:28:11.169]             }
[01:28:11.169]         }))
[01:28:11.169]     }, error = function(ex) {
[01:28:11.169]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.169]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.169]                 ...future.rng), started = ...future.startTime, 
[01:28:11.169]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.169]             version = "1.8"), class = "FutureResult")
[01:28:11.169]     }, finally = {
[01:28:11.169]         if (!identical(...future.workdir, getwd())) 
[01:28:11.169]             setwd(...future.workdir)
[01:28:11.169]         {
[01:28:11.169]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.169]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.169]             }
[01:28:11.169]             base::options(...future.oldOptions)
[01:28:11.169]             if (.Platform$OS.type == "windows") {
[01:28:11.169]                 old_names <- names(...future.oldEnvVars)
[01:28:11.169]                 envs <- base::Sys.getenv()
[01:28:11.169]                 names <- names(envs)
[01:28:11.169]                 common <- intersect(names, old_names)
[01:28:11.169]                 added <- setdiff(names, old_names)
[01:28:11.169]                 removed <- setdiff(old_names, names)
[01:28:11.169]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.169]                   envs[common]]
[01:28:11.169]                 NAMES <- toupper(changed)
[01:28:11.169]                 args <- list()
[01:28:11.169]                 for (kk in seq_along(NAMES)) {
[01:28:11.169]                   name <- changed[[kk]]
[01:28:11.169]                   NAME <- NAMES[[kk]]
[01:28:11.169]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.169]                     next
[01:28:11.169]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.169]                 }
[01:28:11.169]                 NAMES <- toupper(added)
[01:28:11.169]                 for (kk in seq_along(NAMES)) {
[01:28:11.169]                   name <- added[[kk]]
[01:28:11.169]                   NAME <- NAMES[[kk]]
[01:28:11.169]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.169]                     next
[01:28:11.169]                   args[[name]] <- ""
[01:28:11.169]                 }
[01:28:11.169]                 NAMES <- toupper(removed)
[01:28:11.169]                 for (kk in seq_along(NAMES)) {
[01:28:11.169]                   name <- removed[[kk]]
[01:28:11.169]                   NAME <- NAMES[[kk]]
[01:28:11.169]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.169]                     next
[01:28:11.169]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.169]                 }
[01:28:11.169]                 if (length(args) > 0) 
[01:28:11.169]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.169]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.169]             }
[01:28:11.169]             else {
[01:28:11.169]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.169]             }
[01:28:11.169]             {
[01:28:11.169]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.169]                   0L) {
[01:28:11.169]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.169]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.169]                   base::options(opts)
[01:28:11.169]                 }
[01:28:11.169]                 {
[01:28:11.169]                   {
[01:28:11.169]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.169]                     NULL
[01:28:11.169]                   }
[01:28:11.169]                   options(future.plan = NULL)
[01:28:11.169]                   if (is.na(NA_character_)) 
[01:28:11.169]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.169]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.169]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.169]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.169]                     envir = parent.frame()) 
[01:28:11.169]                   {
[01:28:11.169]                     if (is.function(workers)) 
[01:28:11.169]                       workers <- workers()
[01:28:11.169]                     workers <- structure(as.integer(workers), 
[01:28:11.169]                       class = class(workers))
[01:28:11.169]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.169]                       workers >= 1)
[01:28:11.169]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.169]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.169]                     }
[01:28:11.169]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.169]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.169]                       envir = envir)
[01:28:11.169]                     if (!future$lazy) 
[01:28:11.169]                       future <- run(future)
[01:28:11.169]                     invisible(future)
[01:28:11.169]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.169]                 }
[01:28:11.169]             }
[01:28:11.169]         }
[01:28:11.169]     })
[01:28:11.169]     if (TRUE) {
[01:28:11.169]         base::sink(type = "output", split = FALSE)
[01:28:11.169]         if (TRUE) {
[01:28:11.169]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.169]         }
[01:28:11.169]         else {
[01:28:11.169]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.169]         }
[01:28:11.169]         base::close(...future.stdout)
[01:28:11.169]         ...future.stdout <- NULL
[01:28:11.169]     }
[01:28:11.169]     ...future.result$conditions <- ...future.conditions
[01:28:11.169]     ...future.result$finished <- base::Sys.time()
[01:28:11.169]     ...future.result
[01:28:11.169] }
[01:28:11.175] Exporting 1 global objects (1.59 MiB) to cluster node #1 ...
[01:28:11.178] Exporting 'a' (1.59 MiB) to cluster node #1 ...
[01:28:11.190] Exporting 'a' (1.59 MiB) to cluster node #1 ... DONE
[01:28:11.190] Exporting 1 global objects (1.59 MiB) to cluster node #1 ... DONE
[01:28:11.191] MultisessionFuture started
[01:28:11.191] - Launch lazy future ... done
[01:28:11.191] run() for 'MultisessionFuture' ... done
[01:28:11.191] result() for ClusterFuture ...
[01:28:11.191] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.192] - Validating connection of MultisessionFuture
[01:28:11.210] - received message: FutureResult
[01:28:11.210] - Received FutureResult
[01:28:11.210] - Erased future from FutureRegistry
[01:28:11.210] result() for ClusterFuture ...
[01:28:11.210] - result already collected: FutureResult
[01:28:11.211] result() for ClusterFuture ... done
[01:28:11.211] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.211] result() for ClusterFuture ... done
[01:28:11.211] result() for ClusterFuture ...
[01:28:11.211] - result already collected: FutureResult
[01:28:11.211] result() for ClusterFuture ... done
value(b) = 2
[01:28:11.212] result() for ClusterFuture ...
[01:28:11.212] - result already collected: FutureResult
[01:28:11.212] result() for ClusterFuture ... done
[01:28:11.212] result() for ClusterFuture ...
[01:28:11.212] - result already collected: FutureResult
[01:28:11.213] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.213] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.213] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.214] 
[01:28:11.214] Searching for globals ... DONE
[01:28:11.215] - globals: [0] <none>
[01:28:11.215] getGlobalsAndPackages() ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.215] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.216] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.217] - globals found: [3] '+', 'value', 'a'
[01:28:11.217] Searching for globals ... DONE
[01:28:11.217] Resolving globals: TRUE
[01:28:11.217] Resolving any globals that are futures ...
[01:28:11.217] - globals: [3] '+', 'value', 'a'
[01:28:11.217] Resolving any globals that are futures ... DONE
[01:28:11.218] Resolving futures part of globals (recursively) ...
[01:28:11.218] resolve() on list ...
[01:28:11.218]  recursive: 99
[01:28:11.219]  length: 1
[01:28:11.219]  elements: 'a'
[01:28:11.219] run() for 'Future' ...
[01:28:11.219] - state: 'created'
[01:28:11.219] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.234] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.234] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.235]   - Field: 'node'
[01:28:11.235]   - Field: 'label'
[01:28:11.235]   - Field: 'local'
[01:28:11.235]   - Field: 'owner'
[01:28:11.236]   - Field: 'envir'
[01:28:11.236]   - Field: 'workers'
[01:28:11.236]   - Field: 'packages'
[01:28:11.236]   - Field: 'gc'
[01:28:11.236]   - Field: 'conditions'
[01:28:11.236]   - Field: 'persistent'
[01:28:11.237]   - Field: 'expr'
[01:28:11.237]   - Field: 'uuid'
[01:28:11.237]   - Field: 'seed'
[01:28:11.237]   - Field: 'version'
[01:28:11.237]   - Field: 'result'
[01:28:11.238]   - Field: 'asynchronous'
[01:28:11.238]   - Field: 'calls'
[01:28:11.238]   - Field: 'globals'
[01:28:11.238]   - Field: 'stdout'
[01:28:11.238]   - Field: 'earlySignal'
[01:28:11.239]   - Field: 'lazy'
[01:28:11.239]   - Field: 'state'
[01:28:11.239] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.239] - Launch lazy future ...
[01:28:11.239] Packages needed by the future expression (n = 0): <none>
[01:28:11.240] Packages needed by future strategies (n = 0): <none>
[01:28:11.240] {
[01:28:11.240]     {
[01:28:11.240]         {
[01:28:11.240]             ...future.startTime <- base::Sys.time()
[01:28:11.240]             {
[01:28:11.240]                 {
[01:28:11.240]                   {
[01:28:11.240]                     {
[01:28:11.240]                       base::local({
[01:28:11.240]                         has_future <- base::requireNamespace("future", 
[01:28:11.240]                           quietly = TRUE)
[01:28:11.240]                         if (has_future) {
[01:28:11.240]                           ns <- base::getNamespace("future")
[01:28:11.240]                           version <- ns[[".package"]][["version"]]
[01:28:11.240]                           if (is.null(version)) 
[01:28:11.240]                             version <- utils::packageVersion("future")
[01:28:11.240]                         }
[01:28:11.240]                         else {
[01:28:11.240]                           version <- NULL
[01:28:11.240]                         }
[01:28:11.240]                         if (!has_future || version < "1.8.0") {
[01:28:11.240]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.240]                             "", base::R.version$version.string), 
[01:28:11.240]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:11.240]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:11.240]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.240]                               "release", "version")], collapse = " "), 
[01:28:11.240]                             hostname = base::Sys.info()[["nodename"]])
[01:28:11.240]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.240]                             info)
[01:28:11.240]                           info <- base::paste(info, collapse = "; ")
[01:28:11.240]                           if (!has_future) {
[01:28:11.240]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.240]                               info)
[01:28:11.240]                           }
[01:28:11.240]                           else {
[01:28:11.240]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.240]                               info, version)
[01:28:11.240]                           }
[01:28:11.240]                           base::stop(msg)
[01:28:11.240]                         }
[01:28:11.240]                       })
[01:28:11.240]                     }
[01:28:11.240]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.240]                     base::options(mc.cores = 1L)
[01:28:11.240]                   }
[01:28:11.240]                   options(future.plan = NULL)
[01:28:11.240]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.240]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.240]                 }
[01:28:11.240]                 ...future.workdir <- getwd()
[01:28:11.240]             }
[01:28:11.240]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.240]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.240]         }
[01:28:11.240]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.240]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.240]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.240]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.240]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.240]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.240]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.240]             base::names(...future.oldOptions))
[01:28:11.240]     }
[01:28:11.240]     if (FALSE) {
[01:28:11.240]     }
[01:28:11.240]     else {
[01:28:11.240]         if (TRUE) {
[01:28:11.240]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.240]                 open = "w")
[01:28:11.240]         }
[01:28:11.240]         else {
[01:28:11.240]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.240]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.240]         }
[01:28:11.240]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.240]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.240]             base::sink(type = "output", split = FALSE)
[01:28:11.240]             base::close(...future.stdout)
[01:28:11.240]         }, add = TRUE)
[01:28:11.240]     }
[01:28:11.240]     ...future.frame <- base::sys.nframe()
[01:28:11.240]     ...future.conditions <- base::list()
[01:28:11.240]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.240]     if (FALSE) {
[01:28:11.240]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.240]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.240]     }
[01:28:11.240]     ...future.result <- base::tryCatch({
[01:28:11.240]         base::withCallingHandlers({
[01:28:11.240]             ...future.value <- base::withVisible(base::local({
[01:28:11.240]                 ...future.makeSendCondition <- base::local({
[01:28:11.240]                   sendCondition <- NULL
[01:28:11.240]                   function(frame = 1L) {
[01:28:11.240]                     if (is.function(sendCondition)) 
[01:28:11.240]                       return(sendCondition)
[01:28:11.240]                     ns <- getNamespace("parallel")
[01:28:11.240]                     if (exists("sendData", mode = "function", 
[01:28:11.240]                       envir = ns)) {
[01:28:11.240]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.240]                         envir = ns)
[01:28:11.240]                       envir <- sys.frame(frame)
[01:28:11.240]                       master <- NULL
[01:28:11.240]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.240]                         !identical(envir, emptyenv())) {
[01:28:11.240]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.240]                           inherits = FALSE)) {
[01:28:11.240]                           master <- get("master", mode = "list", 
[01:28:11.240]                             envir = envir, inherits = FALSE)
[01:28:11.240]                           if (inherits(master, c("SOCKnode", 
[01:28:11.240]                             "SOCK0node"))) {
[01:28:11.240]                             sendCondition <<- function(cond) {
[01:28:11.240]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.240]                                 success = TRUE)
[01:28:11.240]                               parallel_sendData(master, data)
[01:28:11.240]                             }
[01:28:11.240]                             return(sendCondition)
[01:28:11.240]                           }
[01:28:11.240]                         }
[01:28:11.240]                         frame <- frame + 1L
[01:28:11.240]                         envir <- sys.frame(frame)
[01:28:11.240]                       }
[01:28:11.240]                     }
[01:28:11.240]                     sendCondition <<- function(cond) NULL
[01:28:11.240]                   }
[01:28:11.240]                 })
[01:28:11.240]                 withCallingHandlers({
[01:28:11.240]                   1
[01:28:11.240]                 }, immediateCondition = function(cond) {
[01:28:11.240]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.240]                   sendCondition(cond)
[01:28:11.240]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.240]                   {
[01:28:11.240]                     inherits <- base::inherits
[01:28:11.240]                     invokeRestart <- base::invokeRestart
[01:28:11.240]                     is.null <- base::is.null
[01:28:11.240]                     muffled <- FALSE
[01:28:11.240]                     if (inherits(cond, "message")) {
[01:28:11.240]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.240]                       if (muffled) 
[01:28:11.240]                         invokeRestart("muffleMessage")
[01:28:11.240]                     }
[01:28:11.240]                     else if (inherits(cond, "warning")) {
[01:28:11.240]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.240]                       if (muffled) 
[01:28:11.240]                         invokeRestart("muffleWarning")
[01:28:11.240]                     }
[01:28:11.240]                     else if (inherits(cond, "condition")) {
[01:28:11.240]                       if (!is.null(pattern)) {
[01:28:11.240]                         computeRestarts <- base::computeRestarts
[01:28:11.240]                         grepl <- base::grepl
[01:28:11.240]                         restarts <- computeRestarts(cond)
[01:28:11.240]                         for (restart in restarts) {
[01:28:11.240]                           name <- restart$name
[01:28:11.240]                           if (is.null(name)) 
[01:28:11.240]                             next
[01:28:11.240]                           if (!grepl(pattern, name)) 
[01:28:11.240]                             next
[01:28:11.240]                           invokeRestart(restart)
[01:28:11.240]                           muffled <- TRUE
[01:28:11.240]                           break
[01:28:11.240]                         }
[01:28:11.240]                       }
[01:28:11.240]                     }
[01:28:11.240]                     invisible(muffled)
[01:28:11.240]                   }
[01:28:11.240]                   muffleCondition(cond)
[01:28:11.240]                 })
[01:28:11.240]             }))
[01:28:11.240]             future::FutureResult(value = ...future.value$value, 
[01:28:11.240]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.240]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.240]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.240]                     ...future.globalenv.names))
[01:28:11.240]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.240]         }, condition = base::local({
[01:28:11.240]             c <- base::c
[01:28:11.240]             inherits <- base::inherits
[01:28:11.240]             invokeRestart <- base::invokeRestart
[01:28:11.240]             length <- base::length
[01:28:11.240]             list <- base::list
[01:28:11.240]             seq.int <- base::seq.int
[01:28:11.240]             signalCondition <- base::signalCondition
[01:28:11.240]             sys.calls <- base::sys.calls
[01:28:11.240]             `[[` <- base::`[[`
[01:28:11.240]             `+` <- base::`+`
[01:28:11.240]             `<<-` <- base::`<<-`
[01:28:11.240]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.240]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.240]                   3L)]
[01:28:11.240]             }
[01:28:11.240]             function(cond) {
[01:28:11.240]                 is_error <- inherits(cond, "error")
[01:28:11.240]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.240]                   NULL)
[01:28:11.240]                 if (is_error) {
[01:28:11.240]                   sessionInformation <- function() {
[01:28:11.240]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.240]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.240]                       search = base::search(), system = base::Sys.info())
[01:28:11.240]                   }
[01:28:11.240]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.240]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.240]                     cond$call), session = sessionInformation(), 
[01:28:11.240]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.240]                   signalCondition(cond)
[01:28:11.240]                 }
[01:28:11.240]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.240]                 "immediateCondition"))) {
[01:28:11.240]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.240]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.240]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.240]                   if (TRUE && !signal) {
[01:28:11.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.240]                     {
[01:28:11.240]                       inherits <- base::inherits
[01:28:11.240]                       invokeRestart <- base::invokeRestart
[01:28:11.240]                       is.null <- base::is.null
[01:28:11.240]                       muffled <- FALSE
[01:28:11.240]                       if (inherits(cond, "message")) {
[01:28:11.240]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.240]                         if (muffled) 
[01:28:11.240]                           invokeRestart("muffleMessage")
[01:28:11.240]                       }
[01:28:11.240]                       else if (inherits(cond, "warning")) {
[01:28:11.240]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.240]                         if (muffled) 
[01:28:11.240]                           invokeRestart("muffleWarning")
[01:28:11.240]                       }
[01:28:11.240]                       else if (inherits(cond, "condition")) {
[01:28:11.240]                         if (!is.null(pattern)) {
[01:28:11.240]                           computeRestarts <- base::computeRestarts
[01:28:11.240]                           grepl <- base::grepl
[01:28:11.240]                           restarts <- computeRestarts(cond)
[01:28:11.240]                           for (restart in restarts) {
[01:28:11.240]                             name <- restart$name
[01:28:11.240]                             if (is.null(name)) 
[01:28:11.240]                               next
[01:28:11.240]                             if (!grepl(pattern, name)) 
[01:28:11.240]                               next
[01:28:11.240]                             invokeRestart(restart)
[01:28:11.240]                             muffled <- TRUE
[01:28:11.240]                             break
[01:28:11.240]                           }
[01:28:11.240]                         }
[01:28:11.240]                       }
[01:28:11.240]                       invisible(muffled)
[01:28:11.240]                     }
[01:28:11.240]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.240]                   }
[01:28:11.240]                 }
[01:28:11.240]                 else {
[01:28:11.240]                   if (TRUE) {
[01:28:11.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.240]                     {
[01:28:11.240]                       inherits <- base::inherits
[01:28:11.240]                       invokeRestart <- base::invokeRestart
[01:28:11.240]                       is.null <- base::is.null
[01:28:11.240]                       muffled <- FALSE
[01:28:11.240]                       if (inherits(cond, "message")) {
[01:28:11.240]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.240]                         if (muffled) 
[01:28:11.240]                           invokeRestart("muffleMessage")
[01:28:11.240]                       }
[01:28:11.240]                       else if (inherits(cond, "warning")) {
[01:28:11.240]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.240]                         if (muffled) 
[01:28:11.240]                           invokeRestart("muffleWarning")
[01:28:11.240]                       }
[01:28:11.240]                       else if (inherits(cond, "condition")) {
[01:28:11.240]                         if (!is.null(pattern)) {
[01:28:11.240]                           computeRestarts <- base::computeRestarts
[01:28:11.240]                           grepl <- base::grepl
[01:28:11.240]                           restarts <- computeRestarts(cond)
[01:28:11.240]                           for (restart in restarts) {
[01:28:11.240]                             name <- restart$name
[01:28:11.240]                             if (is.null(name)) 
[01:28:11.240]                               next
[01:28:11.240]                             if (!grepl(pattern, name)) 
[01:28:11.240]                               next
[01:28:11.240]                             invokeRestart(restart)
[01:28:11.240]                             muffled <- TRUE
[01:28:11.240]                             break
[01:28:11.240]                           }
[01:28:11.240]                         }
[01:28:11.240]                       }
[01:28:11.240]                       invisible(muffled)
[01:28:11.240]                     }
[01:28:11.240]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.240]                   }
[01:28:11.240]                 }
[01:28:11.240]             }
[01:28:11.240]         }))
[01:28:11.240]     }, error = function(ex) {
[01:28:11.240]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.240]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.240]                 ...future.rng), started = ...future.startTime, 
[01:28:11.240]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.240]             version = "1.8"), class = "FutureResult")
[01:28:11.240]     }, finally = {
[01:28:11.240]         if (!identical(...future.workdir, getwd())) 
[01:28:11.240]             setwd(...future.workdir)
[01:28:11.240]         {
[01:28:11.240]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.240]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.240]             }
[01:28:11.240]             base::options(...future.oldOptions)
[01:28:11.240]             if (.Platform$OS.type == "windows") {
[01:28:11.240]                 old_names <- names(...future.oldEnvVars)
[01:28:11.240]                 envs <- base::Sys.getenv()
[01:28:11.240]                 names <- names(envs)
[01:28:11.240]                 common <- intersect(names, old_names)
[01:28:11.240]                 added <- setdiff(names, old_names)
[01:28:11.240]                 removed <- setdiff(old_names, names)
[01:28:11.240]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.240]                   envs[common]]
[01:28:11.240]                 NAMES <- toupper(changed)
[01:28:11.240]                 args <- list()
[01:28:11.240]                 for (kk in seq_along(NAMES)) {
[01:28:11.240]                   name <- changed[[kk]]
[01:28:11.240]                   NAME <- NAMES[[kk]]
[01:28:11.240]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.240]                     next
[01:28:11.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.240]                 }
[01:28:11.240]                 NAMES <- toupper(added)
[01:28:11.240]                 for (kk in seq_along(NAMES)) {
[01:28:11.240]                   name <- added[[kk]]
[01:28:11.240]                   NAME <- NAMES[[kk]]
[01:28:11.240]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.240]                     next
[01:28:11.240]                   args[[name]] <- ""
[01:28:11.240]                 }
[01:28:11.240]                 NAMES <- toupper(removed)
[01:28:11.240]                 for (kk in seq_along(NAMES)) {
[01:28:11.240]                   name <- removed[[kk]]
[01:28:11.240]                   NAME <- NAMES[[kk]]
[01:28:11.240]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.240]                     next
[01:28:11.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.240]                 }
[01:28:11.240]                 if (length(args) > 0) 
[01:28:11.240]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.240]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.240]             }
[01:28:11.240]             else {
[01:28:11.240]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.240]             }
[01:28:11.240]             {
[01:28:11.240]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.240]                   0L) {
[01:28:11.240]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.240]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.240]                   base::options(opts)
[01:28:11.240]                 }
[01:28:11.240]                 {
[01:28:11.240]                   {
[01:28:11.240]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.240]                     NULL
[01:28:11.240]                   }
[01:28:11.240]                   options(future.plan = NULL)
[01:28:11.240]                   if (is.na(NA_character_)) 
[01:28:11.240]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.240]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.240]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.240]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.240]                     envir = parent.frame()) 
[01:28:11.240]                   {
[01:28:11.240]                     if (is.function(workers)) 
[01:28:11.240]                       workers <- workers()
[01:28:11.240]                     workers <- structure(as.integer(workers), 
[01:28:11.240]                       class = class(workers))
[01:28:11.240]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.240]                       workers >= 1)
[01:28:11.240]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.240]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.240]                     }
[01:28:11.240]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.240]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.240]                       envir = envir)
[01:28:11.240]                     if (!future$lazy) 
[01:28:11.240]                       future <- run(future)
[01:28:11.240]                     invisible(future)
[01:28:11.240]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.240]                 }
[01:28:11.240]             }
[01:28:11.240]         }
[01:28:11.240]     })
[01:28:11.240]     if (TRUE) {
[01:28:11.240]         base::sink(type = "output", split = FALSE)
[01:28:11.240]         if (TRUE) {
[01:28:11.240]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.240]         }
[01:28:11.240]         else {
[01:28:11.240]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.240]         }
[01:28:11.240]         base::close(...future.stdout)
[01:28:11.240]         ...future.stdout <- NULL
[01:28:11.240]     }
[01:28:11.240]     ...future.result$conditions <- ...future.conditions
[01:28:11.240]     ...future.result$finished <- base::Sys.time()
[01:28:11.240]     ...future.result
[01:28:11.240] }
[01:28:11.246] MultisessionFuture started
[01:28:11.246] - Launch lazy future ... done
[01:28:11.246] run() for 'MultisessionFuture' ... done
[01:28:11.263] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.263] - Validating connection of MultisessionFuture
[01:28:11.263] - received message: FutureResult
[01:28:11.264] - Received FutureResult
[01:28:11.264] - Erased future from FutureRegistry
[01:28:11.264] result() for ClusterFuture ...
[01:28:11.264] - result already collected: FutureResult
[01:28:11.264] result() for ClusterFuture ... done
[01:28:11.265] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.265] Future #1
[01:28:11.265] result() for ClusterFuture ...
[01:28:11.265] - result already collected: FutureResult
[01:28:11.265] result() for ClusterFuture ... done
[01:28:11.265] result() for ClusterFuture ...
[01:28:11.266] - result already collected: FutureResult
[01:28:11.266] result() for ClusterFuture ... done
[01:28:11.266] A MultisessionFuture was resolved
[01:28:11.266]  length: 0 (resolved future 1)
[01:28:11.266] resolve() on list ... DONE
[01:28:11.266] - globals: [1] 'a'
[01:28:11.267] Resolving futures part of globals (recursively) ... DONE
[01:28:11.269] The total size of the 1 globals is 1.59 MiB (1663240 bytes)
[01:28:11.270] The total size of the 1 globals exported for future expression ('value(a) + 1') is 1.59 MiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (1.59 MiB of class 'environment')
[01:28:11.270] - globals: [1] 'a'
[01:28:11.270] - packages: [1] 'future'
[01:28:11.270] getGlobalsAndPackages() ... DONE
[01:28:11.271] run() for 'Future' ...
[01:28:11.271] - state: 'created'
[01:28:11.271] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.286] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.286] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.286]   - Field: 'node'
[01:28:11.286]   - Field: 'label'
[01:28:11.287]   - Field: 'local'
[01:28:11.287]   - Field: 'owner'
[01:28:11.287]   - Field: 'envir'
[01:28:11.287]   - Field: 'workers'
[01:28:11.287]   - Field: 'packages'
[01:28:11.287]   - Field: 'gc'
[01:28:11.288]   - Field: 'conditions'
[01:28:11.288]   - Field: 'persistent'
[01:28:11.288]   - Field: 'expr'
[01:28:11.288]   - Field: 'uuid'
[01:28:11.288]   - Field: 'seed'
[01:28:11.289]   - Field: 'version'
[01:28:11.289]   - Field: 'result'
[01:28:11.289]   - Field: 'asynchronous'
[01:28:11.289]   - Field: 'calls'
[01:28:11.289]   - Field: 'globals'
[01:28:11.289]   - Field: 'stdout'
[01:28:11.290]   - Field: 'earlySignal'
[01:28:11.290]   - Field: 'lazy'
[01:28:11.290]   - Field: 'state'
[01:28:11.290] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.290] - Launch lazy future ...
[01:28:11.291] Packages needed by the future expression (n = 1): 'future'
[01:28:11.294] Packages needed by future strategies (n = 0): <none>
[01:28:11.295] {
[01:28:11.295]     {
[01:28:11.295]         {
[01:28:11.295]             ...future.startTime <- base::Sys.time()
[01:28:11.295]             {
[01:28:11.295]                 {
[01:28:11.295]                   {
[01:28:11.295]                     {
[01:28:11.295]                       {
[01:28:11.295]                         base::local({
[01:28:11.295]                           has_future <- base::requireNamespace("future", 
[01:28:11.295]                             quietly = TRUE)
[01:28:11.295]                           if (has_future) {
[01:28:11.295]                             ns <- base::getNamespace("future")
[01:28:11.295]                             version <- ns[[".package"]][["version"]]
[01:28:11.295]                             if (is.null(version)) 
[01:28:11.295]                               version <- utils::packageVersion("future")
[01:28:11.295]                           }
[01:28:11.295]                           else {
[01:28:11.295]                             version <- NULL
[01:28:11.295]                           }
[01:28:11.295]                           if (!has_future || version < "1.8.0") {
[01:28:11.295]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.295]                               "", base::R.version$version.string), 
[01:28:11.295]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:11.295]                                 base::R.version$platform, 8 * 
[01:28:11.295]                                   base::.Machine$sizeof.pointer), 
[01:28:11.295]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.295]                                 "release", "version")], collapse = " "), 
[01:28:11.295]                               hostname = base::Sys.info()[["nodename"]])
[01:28:11.295]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.295]                               info)
[01:28:11.295]                             info <- base::paste(info, collapse = "; ")
[01:28:11.295]                             if (!has_future) {
[01:28:11.295]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.295]                                 info)
[01:28:11.295]                             }
[01:28:11.295]                             else {
[01:28:11.295]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.295]                                 info, version)
[01:28:11.295]                             }
[01:28:11.295]                             base::stop(msg)
[01:28:11.295]                           }
[01:28:11.295]                         })
[01:28:11.295]                       }
[01:28:11.295]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.295]                       base::options(mc.cores = 1L)
[01:28:11.295]                     }
[01:28:11.295]                     base::local({
[01:28:11.295]                       for (pkg in "future") {
[01:28:11.295]                         base::loadNamespace(pkg)
[01:28:11.295]                         base::library(pkg, character.only = TRUE)
[01:28:11.295]                       }
[01:28:11.295]                     })
[01:28:11.295]                   }
[01:28:11.295]                   options(future.plan = NULL)
[01:28:11.295]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.295]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.295]                 }
[01:28:11.295]                 ...future.workdir <- getwd()
[01:28:11.295]             }
[01:28:11.295]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.295]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.295]         }
[01:28:11.295]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.295]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.295]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.295]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.295]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.295]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.295]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.295]             base::names(...future.oldOptions))
[01:28:11.295]     }
[01:28:11.295]     if (FALSE) {
[01:28:11.295]     }
[01:28:11.295]     else {
[01:28:11.295]         if (TRUE) {
[01:28:11.295]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.295]                 open = "w")
[01:28:11.295]         }
[01:28:11.295]         else {
[01:28:11.295]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.295]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.295]         }
[01:28:11.295]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.295]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.295]             base::sink(type = "output", split = FALSE)
[01:28:11.295]             base::close(...future.stdout)
[01:28:11.295]         }, add = TRUE)
[01:28:11.295]     }
[01:28:11.295]     ...future.frame <- base::sys.nframe()
[01:28:11.295]     ...future.conditions <- base::list()
[01:28:11.295]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.295]     if (FALSE) {
[01:28:11.295]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.295]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.295]     }
[01:28:11.295]     ...future.result <- base::tryCatch({
[01:28:11.295]         base::withCallingHandlers({
[01:28:11.295]             ...future.value <- base::withVisible(base::local({
[01:28:11.295]                 ...future.makeSendCondition <- base::local({
[01:28:11.295]                   sendCondition <- NULL
[01:28:11.295]                   function(frame = 1L) {
[01:28:11.295]                     if (is.function(sendCondition)) 
[01:28:11.295]                       return(sendCondition)
[01:28:11.295]                     ns <- getNamespace("parallel")
[01:28:11.295]                     if (exists("sendData", mode = "function", 
[01:28:11.295]                       envir = ns)) {
[01:28:11.295]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.295]                         envir = ns)
[01:28:11.295]                       envir <- sys.frame(frame)
[01:28:11.295]                       master <- NULL
[01:28:11.295]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.295]                         !identical(envir, emptyenv())) {
[01:28:11.295]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.295]                           inherits = FALSE)) {
[01:28:11.295]                           master <- get("master", mode = "list", 
[01:28:11.295]                             envir = envir, inherits = FALSE)
[01:28:11.295]                           if (inherits(master, c("SOCKnode", 
[01:28:11.295]                             "SOCK0node"))) {
[01:28:11.295]                             sendCondition <<- function(cond) {
[01:28:11.295]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.295]                                 success = TRUE)
[01:28:11.295]                               parallel_sendData(master, data)
[01:28:11.295]                             }
[01:28:11.295]                             return(sendCondition)
[01:28:11.295]                           }
[01:28:11.295]                         }
[01:28:11.295]                         frame <- frame + 1L
[01:28:11.295]                         envir <- sys.frame(frame)
[01:28:11.295]                       }
[01:28:11.295]                     }
[01:28:11.295]                     sendCondition <<- function(cond) NULL
[01:28:11.295]                   }
[01:28:11.295]                 })
[01:28:11.295]                 withCallingHandlers({
[01:28:11.295]                   value(a) + 1
[01:28:11.295]                 }, immediateCondition = function(cond) {
[01:28:11.295]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.295]                   sendCondition(cond)
[01:28:11.295]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.295]                   {
[01:28:11.295]                     inherits <- base::inherits
[01:28:11.295]                     invokeRestart <- base::invokeRestart
[01:28:11.295]                     is.null <- base::is.null
[01:28:11.295]                     muffled <- FALSE
[01:28:11.295]                     if (inherits(cond, "message")) {
[01:28:11.295]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.295]                       if (muffled) 
[01:28:11.295]                         invokeRestart("muffleMessage")
[01:28:11.295]                     }
[01:28:11.295]                     else if (inherits(cond, "warning")) {
[01:28:11.295]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.295]                       if (muffled) 
[01:28:11.295]                         invokeRestart("muffleWarning")
[01:28:11.295]                     }
[01:28:11.295]                     else if (inherits(cond, "condition")) {
[01:28:11.295]                       if (!is.null(pattern)) {
[01:28:11.295]                         computeRestarts <- base::computeRestarts
[01:28:11.295]                         grepl <- base::grepl
[01:28:11.295]                         restarts <- computeRestarts(cond)
[01:28:11.295]                         for (restart in restarts) {
[01:28:11.295]                           name <- restart$name
[01:28:11.295]                           if (is.null(name)) 
[01:28:11.295]                             next
[01:28:11.295]                           if (!grepl(pattern, name)) 
[01:28:11.295]                             next
[01:28:11.295]                           invokeRestart(restart)
[01:28:11.295]                           muffled <- TRUE
[01:28:11.295]                           break
[01:28:11.295]                         }
[01:28:11.295]                       }
[01:28:11.295]                     }
[01:28:11.295]                     invisible(muffled)
[01:28:11.295]                   }
[01:28:11.295]                   muffleCondition(cond)
[01:28:11.295]                 })
[01:28:11.295]             }))
[01:28:11.295]             future::FutureResult(value = ...future.value$value, 
[01:28:11.295]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.295]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.295]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.295]                     ...future.globalenv.names))
[01:28:11.295]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.295]         }, condition = base::local({
[01:28:11.295]             c <- base::c
[01:28:11.295]             inherits <- base::inherits
[01:28:11.295]             invokeRestart <- base::invokeRestart
[01:28:11.295]             length <- base::length
[01:28:11.295]             list <- base::list
[01:28:11.295]             seq.int <- base::seq.int
[01:28:11.295]             signalCondition <- base::signalCondition
[01:28:11.295]             sys.calls <- base::sys.calls
[01:28:11.295]             `[[` <- base::`[[`
[01:28:11.295]             `+` <- base::`+`
[01:28:11.295]             `<<-` <- base::`<<-`
[01:28:11.295]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.295]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.295]                   3L)]
[01:28:11.295]             }
[01:28:11.295]             function(cond) {
[01:28:11.295]                 is_error <- inherits(cond, "error")
[01:28:11.295]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.295]                   NULL)
[01:28:11.295]                 if (is_error) {
[01:28:11.295]                   sessionInformation <- function() {
[01:28:11.295]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.295]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.295]                       search = base::search(), system = base::Sys.info())
[01:28:11.295]                   }
[01:28:11.295]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.295]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.295]                     cond$call), session = sessionInformation(), 
[01:28:11.295]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.295]                   signalCondition(cond)
[01:28:11.295]                 }
[01:28:11.295]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.295]                 "immediateCondition"))) {
[01:28:11.295]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.295]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.295]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.295]                   if (TRUE && !signal) {
[01:28:11.295]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.295]                     {
[01:28:11.295]                       inherits <- base::inherits
[01:28:11.295]                       invokeRestart <- base::invokeRestart
[01:28:11.295]                       is.null <- base::is.null
[01:28:11.295]                       muffled <- FALSE
[01:28:11.295]                       if (inherits(cond, "message")) {
[01:28:11.295]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.295]                         if (muffled) 
[01:28:11.295]                           invokeRestart("muffleMessage")
[01:28:11.295]                       }
[01:28:11.295]                       else if (inherits(cond, "warning")) {
[01:28:11.295]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.295]                         if (muffled) 
[01:28:11.295]                           invokeRestart("muffleWarning")
[01:28:11.295]                       }
[01:28:11.295]                       else if (inherits(cond, "condition")) {
[01:28:11.295]                         if (!is.null(pattern)) {
[01:28:11.295]                           computeRestarts <- base::computeRestarts
[01:28:11.295]                           grepl <- base::grepl
[01:28:11.295]                           restarts <- computeRestarts(cond)
[01:28:11.295]                           for (restart in restarts) {
[01:28:11.295]                             name <- restart$name
[01:28:11.295]                             if (is.null(name)) 
[01:28:11.295]                               next
[01:28:11.295]                             if (!grepl(pattern, name)) 
[01:28:11.295]                               next
[01:28:11.295]                             invokeRestart(restart)
[01:28:11.295]                             muffled <- TRUE
[01:28:11.295]                             break
[01:28:11.295]                           }
[01:28:11.295]                         }
[01:28:11.295]                       }
[01:28:11.295]                       invisible(muffled)
[01:28:11.295]                     }
[01:28:11.295]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.295]                   }
[01:28:11.295]                 }
[01:28:11.295]                 else {
[01:28:11.295]                   if (TRUE) {
[01:28:11.295]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.295]                     {
[01:28:11.295]                       inherits <- base::inherits
[01:28:11.295]                       invokeRestart <- base::invokeRestart
[01:28:11.295]                       is.null <- base::is.null
[01:28:11.295]                       muffled <- FALSE
[01:28:11.295]                       if (inherits(cond, "message")) {
[01:28:11.295]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.295]                         if (muffled) 
[01:28:11.295]                           invokeRestart("muffleMessage")
[01:28:11.295]                       }
[01:28:11.295]                       else if (inherits(cond, "warning")) {
[01:28:11.295]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.295]                         if (muffled) 
[01:28:11.295]                           invokeRestart("muffleWarning")
[01:28:11.295]                       }
[01:28:11.295]                       else if (inherits(cond, "condition")) {
[01:28:11.295]                         if (!is.null(pattern)) {
[01:28:11.295]                           computeRestarts <- base::computeRestarts
[01:28:11.295]                           grepl <- base::grepl
[01:28:11.295]                           restarts <- computeRestarts(cond)
[01:28:11.295]                           for (restart in restarts) {
[01:28:11.295]                             name <- restart$name
[01:28:11.295]                             if (is.null(name)) 
[01:28:11.295]                               next
[01:28:11.295]                             if (!grepl(pattern, name)) 
[01:28:11.295]                               next
[01:28:11.295]                             invokeRestart(restart)
[01:28:11.295]                             muffled <- TRUE
[01:28:11.295]                             break
[01:28:11.295]                           }
[01:28:11.295]                         }
[01:28:11.295]                       }
[01:28:11.295]                       invisible(muffled)
[01:28:11.295]                     }
[01:28:11.295]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.295]                   }
[01:28:11.295]                 }
[01:28:11.295]             }
[01:28:11.295]         }))
[01:28:11.295]     }, error = function(ex) {
[01:28:11.295]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.295]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.295]                 ...future.rng), started = ...future.startTime, 
[01:28:11.295]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.295]             version = "1.8"), class = "FutureResult")
[01:28:11.295]     }, finally = {
[01:28:11.295]         if (!identical(...future.workdir, getwd())) 
[01:28:11.295]             setwd(...future.workdir)
[01:28:11.295]         {
[01:28:11.295]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.295]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.295]             }
[01:28:11.295]             base::options(...future.oldOptions)
[01:28:11.295]             if (.Platform$OS.type == "windows") {
[01:28:11.295]                 old_names <- names(...future.oldEnvVars)
[01:28:11.295]                 envs <- base::Sys.getenv()
[01:28:11.295]                 names <- names(envs)
[01:28:11.295]                 common <- intersect(names, old_names)
[01:28:11.295]                 added <- setdiff(names, old_names)
[01:28:11.295]                 removed <- setdiff(old_names, names)
[01:28:11.295]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.295]                   envs[common]]
[01:28:11.295]                 NAMES <- toupper(changed)
[01:28:11.295]                 args <- list()
[01:28:11.295]                 for (kk in seq_along(NAMES)) {
[01:28:11.295]                   name <- changed[[kk]]
[01:28:11.295]                   NAME <- NAMES[[kk]]
[01:28:11.295]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.295]                     next
[01:28:11.295]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.295]                 }
[01:28:11.295]                 NAMES <- toupper(added)
[01:28:11.295]                 for (kk in seq_along(NAMES)) {
[01:28:11.295]                   name <- added[[kk]]
[01:28:11.295]                   NAME <- NAMES[[kk]]
[01:28:11.295]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.295]                     next
[01:28:11.295]                   args[[name]] <- ""
[01:28:11.295]                 }
[01:28:11.295]                 NAMES <- toupper(removed)
[01:28:11.295]                 for (kk in seq_along(NAMES)) {
[01:28:11.295]                   name <- removed[[kk]]
[01:28:11.295]                   NAME <- NAMES[[kk]]
[01:28:11.295]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.295]                     next
[01:28:11.295]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.295]                 }
[01:28:11.295]                 if (length(args) > 0) 
[01:28:11.295]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.295]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.295]             }
[01:28:11.295]             else {
[01:28:11.295]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.295]             }
[01:28:11.295]             {
[01:28:11.295]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.295]                   0L) {
[01:28:11.295]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.295]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.295]                   base::options(opts)
[01:28:11.295]                 }
[01:28:11.295]                 {
[01:28:11.295]                   {
[01:28:11.295]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.295]                     NULL
[01:28:11.295]                   }
[01:28:11.295]                   options(future.plan = NULL)
[01:28:11.295]                   if (is.na(NA_character_)) 
[01:28:11.295]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.295]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.295]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.295]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.295]                     envir = parent.frame()) 
[01:28:11.295]                   {
[01:28:11.295]                     if (is.function(workers)) 
[01:28:11.295]                       workers <- workers()
[01:28:11.295]                     workers <- structure(as.integer(workers), 
[01:28:11.295]                       class = class(workers))
[01:28:11.295]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.295]                       workers >= 1)
[01:28:11.295]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.295]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.295]                     }
[01:28:11.295]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.295]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.295]                       envir = envir)
[01:28:11.295]                     if (!future$lazy) 
[01:28:11.295]                       future <- run(future)
[01:28:11.295]                     invisible(future)
[01:28:11.295]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.295]                 }
[01:28:11.295]             }
[01:28:11.295]         }
[01:28:11.295]     })
[01:28:11.295]     if (TRUE) {
[01:28:11.295]         base::sink(type = "output", split = FALSE)
[01:28:11.295]         if (TRUE) {
[01:28:11.295]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.295]         }
[01:28:11.295]         else {
[01:28:11.295]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.295]         }
[01:28:11.295]         base::close(...future.stdout)
[01:28:11.295]         ...future.stdout <- NULL
[01:28:11.295]     }
[01:28:11.295]     ...future.result$conditions <- ...future.conditions
[01:28:11.295]     ...future.result$finished <- base::Sys.time()
[01:28:11.295]     ...future.result
[01:28:11.295] }
[01:28:11.300] Exporting 1 global objects (1.59 MiB) to cluster node #1 ...
[01:28:11.303] Exporting 'a' (1.59 MiB) to cluster node #1 ...
[01:28:11.315] Exporting 'a' (1.59 MiB) to cluster node #1 ... DONE
[01:28:11.315] Exporting 1 global objects (1.59 MiB) to cluster node #1 ... DONE
[01:28:11.315] MultisessionFuture started
[01:28:11.316] - Launch lazy future ... done
[01:28:11.316] run() for 'MultisessionFuture' ... done
[01:28:11.316] result() for ClusterFuture ...
[01:28:11.316] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.316] - Validating connection of MultisessionFuture
[01:28:11.333] - received message: FutureResult
[01:28:11.333] - Received FutureResult
[01:28:11.334] - Erased future from FutureRegistry
[01:28:11.334] result() for ClusterFuture ...
[01:28:11.334] - result already collected: FutureResult
[01:28:11.334] result() for ClusterFuture ... done
[01:28:11.334] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.334] result() for ClusterFuture ... done
[01:28:11.334] result() for ClusterFuture ...
[01:28:11.335] - result already collected: FutureResult
[01:28:11.335] result() for ClusterFuture ... done
value(b) = 2
[01:28:11.335] result() for ClusterFuture ...
[01:28:11.335] - result already collected: FutureResult
[01:28:11.336] result() for ClusterFuture ... done
[01:28:11.336] result() for ClusterFuture ...
[01:28:11.336] - result already collected: FutureResult
[01:28:11.336] result() for ClusterFuture ... done
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.337] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.337] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.338] - globals found: [2] '{', 'pkg'
[01:28:11.338] Searching for globals ... DONE
[01:28:11.338] Resolving globals: TRUE
[01:28:11.338] Resolving any globals that are futures ...
[01:28:11.339] - globals: [2] '{', 'pkg'
[01:28:11.339] Resolving any globals that are futures ... DONE
[01:28:11.339] Resolving futures part of globals (recursively) ...
[01:28:11.340] resolve() on list ...
[01:28:11.340]  recursive: 99
[01:28:11.340]  length: 1
[01:28:11.340]  elements: 'pkg'
[01:28:11.340]  length: 0 (resolved future 1)
[01:28:11.340] resolve() on list ... DONE
[01:28:11.341] - globals: [1] 'pkg'
[01:28:11.341] Resolving futures part of globals (recursively) ... DONE
[01:28:11.341] The total size of the 1 globals is 112 bytes (112 bytes)
[01:28:11.342] The total size of the 1 globals exported for future expression ('{; pkg; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'pkg' (112 bytes of class 'character')
[01:28:11.342] - globals: [1] 'pkg'
[01:28:11.342] 
[01:28:11.342] getGlobalsAndPackages() ... DONE
[01:28:11.342] Packages needed by the future expression (n = 0): <none>
[01:28:11.343] Packages needed by future strategies (n = 0): <none>
[01:28:11.343] {
[01:28:11.343]     {
[01:28:11.343]         {
[01:28:11.343]             ...future.startTime <- base::Sys.time()
[01:28:11.343]             {
[01:28:11.343]                 {
[01:28:11.343]                   {
[01:28:11.343]                     base::local({
[01:28:11.343]                       has_future <- base::requireNamespace("future", 
[01:28:11.343]                         quietly = TRUE)
[01:28:11.343]                       if (has_future) {
[01:28:11.343]                         ns <- base::getNamespace("future")
[01:28:11.343]                         version <- ns[[".package"]][["version"]]
[01:28:11.343]                         if (is.null(version)) 
[01:28:11.343]                           version <- utils::packageVersion("future")
[01:28:11.343]                       }
[01:28:11.343]                       else {
[01:28:11.343]                         version <- NULL
[01:28:11.343]                       }
[01:28:11.343]                       if (!has_future || version < "1.8.0") {
[01:28:11.343]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.343]                           "", base::R.version$version.string), 
[01:28:11.343]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:11.343]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:11.343]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.343]                             "release", "version")], collapse = " "), 
[01:28:11.343]                           hostname = base::Sys.info()[["nodename"]])
[01:28:11.343]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.343]                           info)
[01:28:11.343]                         info <- base::paste(info, collapse = "; ")
[01:28:11.343]                         if (!has_future) {
[01:28:11.343]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.343]                             info)
[01:28:11.343]                         }
[01:28:11.343]                         else {
[01:28:11.343]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.343]                             info, version)
[01:28:11.343]                         }
[01:28:11.343]                         base::stop(msg)
[01:28:11.343]                       }
[01:28:11.343]                     })
[01:28:11.343]                   }
[01:28:11.343]                   options(future.plan = NULL)
[01:28:11.343]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.343]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.343]                 }
[01:28:11.343]                 ...future.workdir <- getwd()
[01:28:11.343]             }
[01:28:11.343]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.343]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.343]         }
[01:28:11.343]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.343]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.343]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.343]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.343]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.343]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.343]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.343]             base::names(...future.oldOptions))
[01:28:11.343]     }
[01:28:11.343]     if (FALSE) {
[01:28:11.343]     }
[01:28:11.343]     else {
[01:28:11.343]         if (TRUE) {
[01:28:11.343]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.343]                 open = "w")
[01:28:11.343]         }
[01:28:11.343]         else {
[01:28:11.343]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.343]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.343]         }
[01:28:11.343]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.343]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.343]             base::sink(type = "output", split = FALSE)
[01:28:11.343]             base::close(...future.stdout)
[01:28:11.343]         }, add = TRUE)
[01:28:11.343]     }
[01:28:11.343]     ...future.frame <- base::sys.nframe()
[01:28:11.343]     ...future.conditions <- base::list()
[01:28:11.343]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.343]     if (FALSE) {
[01:28:11.343]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.343]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.343]     }
[01:28:11.343]     ...future.result <- base::tryCatch({
[01:28:11.343]         base::withCallingHandlers({
[01:28:11.343]             ...future.value <- base::withVisible(base::local({
[01:28:11.343]                 pkg
[01:28:11.343]             }))
[01:28:11.343]             future::FutureResult(value = ...future.value$value, 
[01:28:11.343]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.343]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.343]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.343]                     ...future.globalenv.names))
[01:28:11.343]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.343]         }, condition = base::local({
[01:28:11.343]             c <- base::c
[01:28:11.343]             inherits <- base::inherits
[01:28:11.343]             invokeRestart <- base::invokeRestart
[01:28:11.343]             length <- base::length
[01:28:11.343]             list <- base::list
[01:28:11.343]             seq.int <- base::seq.int
[01:28:11.343]             signalCondition <- base::signalCondition
[01:28:11.343]             sys.calls <- base::sys.calls
[01:28:11.343]             `[[` <- base::`[[`
[01:28:11.343]             `+` <- base::`+`
[01:28:11.343]             `<<-` <- base::`<<-`
[01:28:11.343]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.343]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.343]                   3L)]
[01:28:11.343]             }
[01:28:11.343]             function(cond) {
[01:28:11.343]                 is_error <- inherits(cond, "error")
[01:28:11.343]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.343]                   NULL)
[01:28:11.343]                 if (is_error) {
[01:28:11.343]                   sessionInformation <- function() {
[01:28:11.343]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.343]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.343]                       search = base::search(), system = base::Sys.info())
[01:28:11.343]                   }
[01:28:11.343]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.343]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.343]                     cond$call), session = sessionInformation(), 
[01:28:11.343]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.343]                   signalCondition(cond)
[01:28:11.343]                 }
[01:28:11.343]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.343]                 "immediateCondition"))) {
[01:28:11.343]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.343]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.343]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.343]                   if (TRUE && !signal) {
[01:28:11.343]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.343]                     {
[01:28:11.343]                       inherits <- base::inherits
[01:28:11.343]                       invokeRestart <- base::invokeRestart
[01:28:11.343]                       is.null <- base::is.null
[01:28:11.343]                       muffled <- FALSE
[01:28:11.343]                       if (inherits(cond, "message")) {
[01:28:11.343]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.343]                         if (muffled) 
[01:28:11.343]                           invokeRestart("muffleMessage")
[01:28:11.343]                       }
[01:28:11.343]                       else if (inherits(cond, "warning")) {
[01:28:11.343]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.343]                         if (muffled) 
[01:28:11.343]                           invokeRestart("muffleWarning")
[01:28:11.343]                       }
[01:28:11.343]                       else if (inherits(cond, "condition")) {
[01:28:11.343]                         if (!is.null(pattern)) {
[01:28:11.343]                           computeRestarts <- base::computeRestarts
[01:28:11.343]                           grepl <- base::grepl
[01:28:11.343]                           restarts <- computeRestarts(cond)
[01:28:11.343]                           for (restart in restarts) {
[01:28:11.343]                             name <- restart$name
[01:28:11.343]                             if (is.null(name)) 
[01:28:11.343]                               next
[01:28:11.343]                             if (!grepl(pattern, name)) 
[01:28:11.343]                               next
[01:28:11.343]                             invokeRestart(restart)
[01:28:11.343]                             muffled <- TRUE
[01:28:11.343]                             break
[01:28:11.343]                           }
[01:28:11.343]                         }
[01:28:11.343]                       }
[01:28:11.343]                       invisible(muffled)
[01:28:11.343]                     }
[01:28:11.343]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.343]                   }
[01:28:11.343]                 }
[01:28:11.343]                 else {
[01:28:11.343]                   if (TRUE) {
[01:28:11.343]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.343]                     {
[01:28:11.343]                       inherits <- base::inherits
[01:28:11.343]                       invokeRestart <- base::invokeRestart
[01:28:11.343]                       is.null <- base::is.null
[01:28:11.343]                       muffled <- FALSE
[01:28:11.343]                       if (inherits(cond, "message")) {
[01:28:11.343]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.343]                         if (muffled) 
[01:28:11.343]                           invokeRestart("muffleMessage")
[01:28:11.343]                       }
[01:28:11.343]                       else if (inherits(cond, "warning")) {
[01:28:11.343]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.343]                         if (muffled) 
[01:28:11.343]                           invokeRestart("muffleWarning")
[01:28:11.343]                       }
[01:28:11.343]                       else if (inherits(cond, "condition")) {
[01:28:11.343]                         if (!is.null(pattern)) {
[01:28:11.343]                           computeRestarts <- base::computeRestarts
[01:28:11.343]                           grepl <- base::grepl
[01:28:11.343]                           restarts <- computeRestarts(cond)
[01:28:11.343]                           for (restart in restarts) {
[01:28:11.343]                             name <- restart$name
[01:28:11.343]                             if (is.null(name)) 
[01:28:11.343]                               next
[01:28:11.343]                             if (!grepl(pattern, name)) 
[01:28:11.343]                               next
[01:28:11.343]                             invokeRestart(restart)
[01:28:11.343]                             muffled <- TRUE
[01:28:11.343]                             break
[01:28:11.343]                           }
[01:28:11.343]                         }
[01:28:11.343]                       }
[01:28:11.343]                       invisible(muffled)
[01:28:11.343]                     }
[01:28:11.343]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.343]                   }
[01:28:11.343]                 }
[01:28:11.343]             }
[01:28:11.343]         }))
[01:28:11.343]     }, error = function(ex) {
[01:28:11.343]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.343]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.343]                 ...future.rng), started = ...future.startTime, 
[01:28:11.343]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.343]             version = "1.8"), class = "FutureResult")
[01:28:11.343]     }, finally = {
[01:28:11.343]         if (!identical(...future.workdir, getwd())) 
[01:28:11.343]             setwd(...future.workdir)
[01:28:11.343]         {
[01:28:11.343]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.343]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.343]             }
[01:28:11.343]             base::options(...future.oldOptions)
[01:28:11.343]             if (.Platform$OS.type == "windows") {
[01:28:11.343]                 old_names <- names(...future.oldEnvVars)
[01:28:11.343]                 envs <- base::Sys.getenv()
[01:28:11.343]                 names <- names(envs)
[01:28:11.343]                 common <- intersect(names, old_names)
[01:28:11.343]                 added <- setdiff(names, old_names)
[01:28:11.343]                 removed <- setdiff(old_names, names)
[01:28:11.343]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.343]                   envs[common]]
[01:28:11.343]                 NAMES <- toupper(changed)
[01:28:11.343]                 args <- list()
[01:28:11.343]                 for (kk in seq_along(NAMES)) {
[01:28:11.343]                   name <- changed[[kk]]
[01:28:11.343]                   NAME <- NAMES[[kk]]
[01:28:11.343]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.343]                     next
[01:28:11.343]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.343]                 }
[01:28:11.343]                 NAMES <- toupper(added)
[01:28:11.343]                 for (kk in seq_along(NAMES)) {
[01:28:11.343]                   name <- added[[kk]]
[01:28:11.343]                   NAME <- NAMES[[kk]]
[01:28:11.343]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.343]                     next
[01:28:11.343]                   args[[name]] <- ""
[01:28:11.343]                 }
[01:28:11.343]                 NAMES <- toupper(removed)
[01:28:11.343]                 for (kk in seq_along(NAMES)) {
[01:28:11.343]                   name <- removed[[kk]]
[01:28:11.343]                   NAME <- NAMES[[kk]]
[01:28:11.343]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.343]                     next
[01:28:11.343]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.343]                 }
[01:28:11.343]                 if (length(args) > 0) 
[01:28:11.343]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.343]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.343]             }
[01:28:11.343]             else {
[01:28:11.343]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.343]             }
[01:28:11.343]             {
[01:28:11.343]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.343]                   0L) {
[01:28:11.343]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.343]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.343]                   base::options(opts)
[01:28:11.343]                 }
[01:28:11.343]                 {
[01:28:11.343]                   {
[01:28:11.343]                     NULL
[01:28:11.343]                     RNGkind("Mersenne-Twister")
[01:28:11.343]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:11.343]                       inherits = FALSE)
[01:28:11.343]                   }
[01:28:11.343]                   options(future.plan = NULL)
[01:28:11.343]                   if (is.na(NA_character_)) 
[01:28:11.343]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.343]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.343]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.343]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.343]                     envir = parent.frame()) 
[01:28:11.343]                   {
[01:28:11.343]                     if (is.function(workers)) 
[01:28:11.343]                       workers <- workers()
[01:28:11.343]                     workers <- structure(as.integer(workers), 
[01:28:11.343]                       class = class(workers))
[01:28:11.343]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.343]                       workers >= 1)
[01:28:11.343]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.343]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.343]                     }
[01:28:11.343]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.343]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.343]                       envir = envir)
[01:28:11.343]                     if (!future$lazy) 
[01:28:11.343]                       future <- run(future)
[01:28:11.343]                     invisible(future)
[01:28:11.343]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.343]                 }
[01:28:11.343]             }
[01:28:11.343]         }
[01:28:11.343]     })
[01:28:11.343]     if (TRUE) {
[01:28:11.343]         base::sink(type = "output", split = FALSE)
[01:28:11.343]         if (TRUE) {
[01:28:11.343]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.343]         }
[01:28:11.343]         else {
[01:28:11.343]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.343]         }
[01:28:11.343]         base::close(...future.stdout)
[01:28:11.343]         ...future.stdout <- NULL
[01:28:11.343]     }
[01:28:11.343]     ...future.result$conditions <- ...future.conditions
[01:28:11.343]     ...future.result$finished <- base::Sys.time()
[01:28:11.343]     ...future.result
[01:28:11.343] }
[01:28:11.347] assign_globals() ...
[01:28:11.347] List of 1
[01:28:11.347]  $ pkg: chr "foo"
[01:28:11.347]  - attr(*, "where")=List of 1
[01:28:11.347]   ..$ pkg:<environment: R_EmptyEnv> 
[01:28:11.347]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:11.347]  - attr(*, "resolved")= logi TRUE
[01:28:11.347]  - attr(*, "total_size")= num 112
[01:28:11.350] - copied 'pkg' to environment
[01:28:11.350] assign_globals() ... done
[01:28:11.351] plan(): Setting new future strategy stack:
[01:28:11.351] List of future strategies:
[01:28:11.351] 1. sequential:
[01:28:11.351]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:11.351]    - tweaked: FALSE
[01:28:11.351]    - call: NULL
[01:28:11.352] plan(): nbrOfWorkers() = 1
[01:28:11.353] plan(): Setting new future strategy stack:
[01:28:11.353] List of future strategies:
[01:28:11.353] 1. multisession:
[01:28:11.353]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:11.353]    - tweaked: FALSE
[01:28:11.353]    - call: plan(strategy)
[01:28:11.356] plan(): nbrOfWorkers() = 2
[01:28:11.356] SequentialFuture started (and completed)
value(f) = 'foo'
Method for identifying globals: 'ordered' ... DONE
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.357] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.357] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.359] - globals found: [3] '{', '<-', '+'
[01:28:11.360] Searching for globals ... DONE
[01:28:11.360] Resolving globals: TRUE
[01:28:11.360] Resolving any globals that are futures ...
[01:28:11.360] - globals: [3] '{', '<-', '+'
[01:28:11.360] Resolving any globals that are futures ... DONE
[01:28:11.361] 
[01:28:11.361] 
[01:28:11.361] getGlobalsAndPackages() ... DONE
[01:28:11.361] run() for 'Future' ...
[01:28:11.362] - state: 'created'
[01:28:11.362] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.377] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.378] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.378]   - Field: 'node'
[01:28:11.378]   - Field: 'label'
[01:28:11.379]   - Field: 'local'
[01:28:11.379]   - Field: 'owner'
[01:28:11.379]   - Field: 'envir'
[01:28:11.379]   - Field: 'workers'
[01:28:11.380]   - Field: 'packages'
[01:28:11.380]   - Field: 'gc'
[01:28:11.380]   - Field: 'conditions'
[01:28:11.381]   - Field: 'persistent'
[01:28:11.381]   - Field: 'expr'
[01:28:11.381]   - Field: 'uuid'
[01:28:11.381]   - Field: 'seed'
[01:28:11.382]   - Field: 'version'
[01:28:11.382]   - Field: 'result'
[01:28:11.382]   - Field: 'asynchronous'
[01:28:11.382]   - Field: 'calls'
[01:28:11.383]   - Field: 'globals'
[01:28:11.383]   - Field: 'stdout'
[01:28:11.383]   - Field: 'earlySignal'
[01:28:11.384]   - Field: 'lazy'
[01:28:11.384]   - Field: 'state'
[01:28:11.384] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.384] - Launch lazy future ...
[01:28:11.385] Packages needed by the future expression (n = 0): <none>
[01:28:11.385] Packages needed by future strategies (n = 0): <none>
[01:28:11.386] {
[01:28:11.386]     {
[01:28:11.386]         {
[01:28:11.386]             ...future.startTime <- base::Sys.time()
[01:28:11.386]             {
[01:28:11.386]                 {
[01:28:11.386]                   {
[01:28:11.386]                     {
[01:28:11.386]                       base::local({
[01:28:11.386]                         has_future <- base::requireNamespace("future", 
[01:28:11.386]                           quietly = TRUE)
[01:28:11.386]                         if (has_future) {
[01:28:11.386]                           ns <- base::getNamespace("future")
[01:28:11.386]                           version <- ns[[".package"]][["version"]]
[01:28:11.386]                           if (is.null(version)) 
[01:28:11.386]                             version <- utils::packageVersion("future")
[01:28:11.386]                         }
[01:28:11.386]                         else {
[01:28:11.386]                           version <- NULL
[01:28:11.386]                         }
[01:28:11.386]                         if (!has_future || version < "1.8.0") {
[01:28:11.386]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.386]                             "", base::R.version$version.string), 
[01:28:11.386]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:11.386]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:11.386]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.386]                               "release", "version")], collapse = " "), 
[01:28:11.386]                             hostname = base::Sys.info()[["nodename"]])
[01:28:11.386]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.386]                             info)
[01:28:11.386]                           info <- base::paste(info, collapse = "; ")
[01:28:11.386]                           if (!has_future) {
[01:28:11.386]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.386]                               info)
[01:28:11.386]                           }
[01:28:11.386]                           else {
[01:28:11.386]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.386]                               info, version)
[01:28:11.386]                           }
[01:28:11.386]                           base::stop(msg)
[01:28:11.386]                         }
[01:28:11.386]                       })
[01:28:11.386]                     }
[01:28:11.386]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.386]                     base::options(mc.cores = 1L)
[01:28:11.386]                   }
[01:28:11.386]                   options(future.plan = NULL)
[01:28:11.386]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.386]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.386]                 }
[01:28:11.386]                 ...future.workdir <- getwd()
[01:28:11.386]             }
[01:28:11.386]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.386]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.386]         }
[01:28:11.386]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.386]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.386]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.386]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.386]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.386]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.386]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.386]             base::names(...future.oldOptions))
[01:28:11.386]     }
[01:28:11.386]     if (FALSE) {
[01:28:11.386]     }
[01:28:11.386]     else {
[01:28:11.386]         if (TRUE) {
[01:28:11.386]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.386]                 open = "w")
[01:28:11.386]         }
[01:28:11.386]         else {
[01:28:11.386]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.386]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.386]         }
[01:28:11.386]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.386]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.386]             base::sink(type = "output", split = FALSE)
[01:28:11.386]             base::close(...future.stdout)
[01:28:11.386]         }, add = TRUE)
[01:28:11.386]     }
[01:28:11.386]     ...future.frame <- base::sys.nframe()
[01:28:11.386]     ...future.conditions <- base::list()
[01:28:11.386]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.386]     if (FALSE) {
[01:28:11.386]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.386]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.386]     }
[01:28:11.386]     ...future.result <- base::tryCatch({
[01:28:11.386]         base::withCallingHandlers({
[01:28:11.386]             ...future.value <- base::withVisible(base::local({
[01:28:11.386]                 ...future.makeSendCondition <- base::local({
[01:28:11.386]                   sendCondition <- NULL
[01:28:11.386]                   function(frame = 1L) {
[01:28:11.386]                     if (is.function(sendCondition)) 
[01:28:11.386]                       return(sendCondition)
[01:28:11.386]                     ns <- getNamespace("parallel")
[01:28:11.386]                     if (exists("sendData", mode = "function", 
[01:28:11.386]                       envir = ns)) {
[01:28:11.386]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.386]                         envir = ns)
[01:28:11.386]                       envir <- sys.frame(frame)
[01:28:11.386]                       master <- NULL
[01:28:11.386]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.386]                         !identical(envir, emptyenv())) {
[01:28:11.386]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.386]                           inherits = FALSE)) {
[01:28:11.386]                           master <- get("master", mode = "list", 
[01:28:11.386]                             envir = envir, inherits = FALSE)
[01:28:11.386]                           if (inherits(master, c("SOCKnode", 
[01:28:11.386]                             "SOCK0node"))) {
[01:28:11.386]                             sendCondition <<- function(cond) {
[01:28:11.386]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.386]                                 success = TRUE)
[01:28:11.386]                               parallel_sendData(master, data)
[01:28:11.386]                             }
[01:28:11.386]                             return(sendCondition)
[01:28:11.386]                           }
[01:28:11.386]                         }
[01:28:11.386]                         frame <- frame + 1L
[01:28:11.386]                         envir <- sys.frame(frame)
[01:28:11.386]                       }
[01:28:11.386]                     }
[01:28:11.386]                     sendCondition <<- function(cond) NULL
[01:28:11.386]                   }
[01:28:11.386]                 })
[01:28:11.386]                 withCallingHandlers({
[01:28:11.386]                   {
[01:28:11.386]                     x <- 0
[01:28:11.386]                     x <- x + 1
[01:28:11.386]                     x
[01:28:11.386]                   }
[01:28:11.386]                 }, immediateCondition = function(cond) {
[01:28:11.386]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.386]                   sendCondition(cond)
[01:28:11.386]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.386]                   {
[01:28:11.386]                     inherits <- base::inherits
[01:28:11.386]                     invokeRestart <- base::invokeRestart
[01:28:11.386]                     is.null <- base::is.null
[01:28:11.386]                     muffled <- FALSE
[01:28:11.386]                     if (inherits(cond, "message")) {
[01:28:11.386]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.386]                       if (muffled) 
[01:28:11.386]                         invokeRestart("muffleMessage")
[01:28:11.386]                     }
[01:28:11.386]                     else if (inherits(cond, "warning")) {
[01:28:11.386]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.386]                       if (muffled) 
[01:28:11.386]                         invokeRestart("muffleWarning")
[01:28:11.386]                     }
[01:28:11.386]                     else if (inherits(cond, "condition")) {
[01:28:11.386]                       if (!is.null(pattern)) {
[01:28:11.386]                         computeRestarts <- base::computeRestarts
[01:28:11.386]                         grepl <- base::grepl
[01:28:11.386]                         restarts <- computeRestarts(cond)
[01:28:11.386]                         for (restart in restarts) {
[01:28:11.386]                           name <- restart$name
[01:28:11.386]                           if (is.null(name)) 
[01:28:11.386]                             next
[01:28:11.386]                           if (!grepl(pattern, name)) 
[01:28:11.386]                             next
[01:28:11.386]                           invokeRestart(restart)
[01:28:11.386]                           muffled <- TRUE
[01:28:11.386]                           break
[01:28:11.386]                         }
[01:28:11.386]                       }
[01:28:11.386]                     }
[01:28:11.386]                     invisible(muffled)
[01:28:11.386]                   }
[01:28:11.386]                   muffleCondition(cond)
[01:28:11.386]                 })
[01:28:11.386]             }))
[01:28:11.386]             future::FutureResult(value = ...future.value$value, 
[01:28:11.386]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.386]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.386]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.386]                     ...future.globalenv.names))
[01:28:11.386]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.386]         }, condition = base::local({
[01:28:11.386]             c <- base::c
[01:28:11.386]             inherits <- base::inherits
[01:28:11.386]             invokeRestart <- base::invokeRestart
[01:28:11.386]             length <- base::length
[01:28:11.386]             list <- base::list
[01:28:11.386]             seq.int <- base::seq.int
[01:28:11.386]             signalCondition <- base::signalCondition
[01:28:11.386]             sys.calls <- base::sys.calls
[01:28:11.386]             `[[` <- base::`[[`
[01:28:11.386]             `+` <- base::`+`
[01:28:11.386]             `<<-` <- base::`<<-`
[01:28:11.386]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.386]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.386]                   3L)]
[01:28:11.386]             }
[01:28:11.386]             function(cond) {
[01:28:11.386]                 is_error <- inherits(cond, "error")
[01:28:11.386]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.386]                   NULL)
[01:28:11.386]                 if (is_error) {
[01:28:11.386]                   sessionInformation <- function() {
[01:28:11.386]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.386]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.386]                       search = base::search(), system = base::Sys.info())
[01:28:11.386]                   }
[01:28:11.386]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.386]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.386]                     cond$call), session = sessionInformation(), 
[01:28:11.386]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.386]                   signalCondition(cond)
[01:28:11.386]                 }
[01:28:11.386]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.386]                 "immediateCondition"))) {
[01:28:11.386]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.386]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.386]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.386]                   if (TRUE && !signal) {
[01:28:11.386]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.386]                     {
[01:28:11.386]                       inherits <- base::inherits
[01:28:11.386]                       invokeRestart <- base::invokeRestart
[01:28:11.386]                       is.null <- base::is.null
[01:28:11.386]                       muffled <- FALSE
[01:28:11.386]                       if (inherits(cond, "message")) {
[01:28:11.386]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.386]                         if (muffled) 
[01:28:11.386]                           invokeRestart("muffleMessage")
[01:28:11.386]                       }
[01:28:11.386]                       else if (inherits(cond, "warning")) {
[01:28:11.386]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.386]                         if (muffled) 
[01:28:11.386]                           invokeRestart("muffleWarning")
[01:28:11.386]                       }
[01:28:11.386]                       else if (inherits(cond, "condition")) {
[01:28:11.386]                         if (!is.null(pattern)) {
[01:28:11.386]                           computeRestarts <- base::computeRestarts
[01:28:11.386]                           grepl <- base::grepl
[01:28:11.386]                           restarts <- computeRestarts(cond)
[01:28:11.386]                           for (restart in restarts) {
[01:28:11.386]                             name <- restart$name
[01:28:11.386]                             if (is.null(name)) 
[01:28:11.386]                               next
[01:28:11.386]                             if (!grepl(pattern, name)) 
[01:28:11.386]                               next
[01:28:11.386]                             invokeRestart(restart)
[01:28:11.386]                             muffled <- TRUE
[01:28:11.386]                             break
[01:28:11.386]                           }
[01:28:11.386]                         }
[01:28:11.386]                       }
[01:28:11.386]                       invisible(muffled)
[01:28:11.386]                     }
[01:28:11.386]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.386]                   }
[01:28:11.386]                 }
[01:28:11.386]                 else {
[01:28:11.386]                   if (TRUE) {
[01:28:11.386]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.386]                     {
[01:28:11.386]                       inherits <- base::inherits
[01:28:11.386]                       invokeRestart <- base::invokeRestart
[01:28:11.386]                       is.null <- base::is.null
[01:28:11.386]                       muffled <- FALSE
[01:28:11.386]                       if (inherits(cond, "message")) {
[01:28:11.386]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.386]                         if (muffled) 
[01:28:11.386]                           invokeRestart("muffleMessage")
[01:28:11.386]                       }
[01:28:11.386]                       else if (inherits(cond, "warning")) {
[01:28:11.386]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.386]                         if (muffled) 
[01:28:11.386]                           invokeRestart("muffleWarning")
[01:28:11.386]                       }
[01:28:11.386]                       else if (inherits(cond, "condition")) {
[01:28:11.386]                         if (!is.null(pattern)) {
[01:28:11.386]                           computeRestarts <- base::computeRestarts
[01:28:11.386]                           grepl <- base::grepl
[01:28:11.386]                           restarts <- computeRestarts(cond)
[01:28:11.386]                           for (restart in restarts) {
[01:28:11.386]                             name <- restart$name
[01:28:11.386]                             if (is.null(name)) 
[01:28:11.386]                               next
[01:28:11.386]                             if (!grepl(pattern, name)) 
[01:28:11.386]                               next
[01:28:11.386]                             invokeRestart(restart)
[01:28:11.386]                             muffled <- TRUE
[01:28:11.386]                             break
[01:28:11.386]                           }
[01:28:11.386]                         }
[01:28:11.386]                       }
[01:28:11.386]                       invisible(muffled)
[01:28:11.386]                     }
[01:28:11.386]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.386]                   }
[01:28:11.386]                 }
[01:28:11.386]             }
[01:28:11.386]         }))
[01:28:11.386]     }, error = function(ex) {
[01:28:11.386]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.386]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.386]                 ...future.rng), started = ...future.startTime, 
[01:28:11.386]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.386]             version = "1.8"), class = "FutureResult")
[01:28:11.386]     }, finally = {
[01:28:11.386]         if (!identical(...future.workdir, getwd())) 
[01:28:11.386]             setwd(...future.workdir)
[01:28:11.386]         {
[01:28:11.386]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.386]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.386]             }
[01:28:11.386]             base::options(...future.oldOptions)
[01:28:11.386]             if (.Platform$OS.type == "windows") {
[01:28:11.386]                 old_names <- names(...future.oldEnvVars)
[01:28:11.386]                 envs <- base::Sys.getenv()
[01:28:11.386]                 names <- names(envs)
[01:28:11.386]                 common <- intersect(names, old_names)
[01:28:11.386]                 added <- setdiff(names, old_names)
[01:28:11.386]                 removed <- setdiff(old_names, names)
[01:28:11.386]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.386]                   envs[common]]
[01:28:11.386]                 NAMES <- toupper(changed)
[01:28:11.386]                 args <- list()
[01:28:11.386]                 for (kk in seq_along(NAMES)) {
[01:28:11.386]                   name <- changed[[kk]]
[01:28:11.386]                   NAME <- NAMES[[kk]]
[01:28:11.386]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.386]                     next
[01:28:11.386]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.386]                 }
[01:28:11.386]                 NAMES <- toupper(added)
[01:28:11.386]                 for (kk in seq_along(NAMES)) {
[01:28:11.386]                   name <- added[[kk]]
[01:28:11.386]                   NAME <- NAMES[[kk]]
[01:28:11.386]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.386]                     next
[01:28:11.386]                   args[[name]] <- ""
[01:28:11.386]                 }
[01:28:11.386]                 NAMES <- toupper(removed)
[01:28:11.386]                 for (kk in seq_along(NAMES)) {
[01:28:11.386]                   name <- removed[[kk]]
[01:28:11.386]                   NAME <- NAMES[[kk]]
[01:28:11.386]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.386]                     next
[01:28:11.386]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.386]                 }
[01:28:11.386]                 if (length(args) > 0) 
[01:28:11.386]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.386]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.386]             }
[01:28:11.386]             else {
[01:28:11.386]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.386]             }
[01:28:11.386]             {
[01:28:11.386]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.386]                   0L) {
[01:28:11.386]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.386]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.386]                   base::options(opts)
[01:28:11.386]                 }
[01:28:11.386]                 {
[01:28:11.386]                   {
[01:28:11.386]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.386]                     NULL
[01:28:11.386]                   }
[01:28:11.386]                   options(future.plan = NULL)
[01:28:11.386]                   if (is.na(NA_character_)) 
[01:28:11.386]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.386]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.386]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.386]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.386]                     envir = parent.frame()) 
[01:28:11.386]                   {
[01:28:11.386]                     if (is.function(workers)) 
[01:28:11.386]                       workers <- workers()
[01:28:11.386]                     workers <- structure(as.integer(workers), 
[01:28:11.386]                       class = class(workers))
[01:28:11.386]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.386]                       workers >= 1)
[01:28:11.386]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.386]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.386]                     }
[01:28:11.386]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.386]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.386]                       envir = envir)
[01:28:11.386]                     if (!future$lazy) 
[01:28:11.386]                       future <- run(future)
[01:28:11.386]                     invisible(future)
[01:28:11.386]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.386]                 }
[01:28:11.386]             }
[01:28:11.386]         }
[01:28:11.386]     })
[01:28:11.386]     if (TRUE) {
[01:28:11.386]         base::sink(type = "output", split = FALSE)
[01:28:11.386]         if (TRUE) {
[01:28:11.386]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.386]         }
[01:28:11.386]         else {
[01:28:11.386]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.386]         }
[01:28:11.386]         base::close(...future.stdout)
[01:28:11.386]         ...future.stdout <- NULL
[01:28:11.386]     }
[01:28:11.386]     ...future.result$conditions <- ...future.conditions
[01:28:11.386]     ...future.result$finished <- base::Sys.time()
[01:28:11.386]     ...future.result
[01:28:11.386] }
[01:28:11.395] MultisessionFuture started
[01:28:11.395] - Launch lazy future ... done
[01:28:11.396] run() for 'MultisessionFuture' ... done
[01:28:11.396] result() for ClusterFuture ...
[01:28:11.396] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.396] - Validating connection of MultisessionFuture
[01:28:11.412] - received message: FutureResult
[01:28:11.413] - Received FutureResult
[01:28:11.413] - Erased future from FutureRegistry
[01:28:11.413] result() for ClusterFuture ...
[01:28:11.413] - result already collected: FutureResult
[01:28:11.413] result() for ClusterFuture ... done
[01:28:11.414] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.414] result() for ClusterFuture ... done
[01:28:11.414] result() for ClusterFuture ...
[01:28:11.414] - result already collected: FutureResult
[01:28:11.414] result() for ClusterFuture ... done
value(f) = '1'
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.415] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.415] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.418] - globals found: [4] '{', '<-', 'x', '+'
[01:28:11.418] Searching for globals ... DONE
[01:28:11.418] Resolving globals: TRUE
[01:28:11.418] Resolving any globals that are futures ...
[01:28:11.419] - globals: [4] '{', '<-', 'x', '+'
[01:28:11.419] Resolving any globals that are futures ... DONE
[01:28:11.420] Resolving futures part of globals (recursively) ...
[01:28:11.420] resolve() on list ...
[01:28:11.420]  recursive: 99
[01:28:11.421]  length: 1
[01:28:11.421]  elements: 'x'
[01:28:11.421]  length: 0 (resolved future 1)
[01:28:11.422] resolve() on list ... DONE
[01:28:11.422] - globals: [1] 'x'
[01:28:11.422] Resolving futures part of globals (recursively) ... DONE
[01:28:11.422] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:11.423] The total size of the 1 globals exported for future expression ('{; x <- x + 1; x; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (56 bytes of class 'numeric')
[01:28:11.423] - globals: [1] 'x'
[01:28:11.424] 
[01:28:11.424] getGlobalsAndPackages() ... DONE
[01:28:11.425] run() for 'Future' ...
[01:28:11.425] - state: 'created'
[01:28:11.425] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.444] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.444] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.444]   - Field: 'node'
[01:28:11.445]   - Field: 'label'
[01:28:11.445]   - Field: 'local'
[01:28:11.446]   - Field: 'owner'
[01:28:11.446]   - Field: 'envir'
[01:28:11.446]   - Field: 'workers'
[01:28:11.447]   - Field: 'packages'
[01:28:11.447]   - Field: 'gc'
[01:28:11.447]   - Field: 'conditions'
[01:28:11.448]   - Field: 'persistent'
[01:28:11.448]   - Field: 'expr'
[01:28:11.448]   - Field: 'uuid'
[01:28:11.449]   - Field: 'seed'
[01:28:11.449]   - Field: 'version'
[01:28:11.449]   - Field: 'result'
[01:28:11.450]   - Field: 'asynchronous'
[01:28:11.450]   - Field: 'calls'
[01:28:11.450]   - Field: 'globals'
[01:28:11.450]   - Field: 'stdout'
[01:28:11.451]   - Field: 'earlySignal'
[01:28:11.451]   - Field: 'lazy'
[01:28:11.451]   - Field: 'state'
[01:28:11.452] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.452] - Launch lazy future ...
[01:28:11.453] Packages needed by the future expression (n = 0): <none>
[01:28:11.453] Packages needed by future strategies (n = 0): <none>
[01:28:11.454] {
[01:28:11.454]     {
[01:28:11.454]         {
[01:28:11.454]             ...future.startTime <- base::Sys.time()
[01:28:11.454]             {
[01:28:11.454]                 {
[01:28:11.454]                   {
[01:28:11.454]                     {
[01:28:11.454]                       base::local({
[01:28:11.454]                         has_future <- base::requireNamespace("future", 
[01:28:11.454]                           quietly = TRUE)
[01:28:11.454]                         if (has_future) {
[01:28:11.454]                           ns <- base::getNamespace("future")
[01:28:11.454]                           version <- ns[[".package"]][["version"]]
[01:28:11.454]                           if (is.null(version)) 
[01:28:11.454]                             version <- utils::packageVersion("future")
[01:28:11.454]                         }
[01:28:11.454]                         else {
[01:28:11.454]                           version <- NULL
[01:28:11.454]                         }
[01:28:11.454]                         if (!has_future || version < "1.8.0") {
[01:28:11.454]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.454]                             "", base::R.version$version.string), 
[01:28:11.454]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:11.454]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:11.454]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.454]                               "release", "version")], collapse = " "), 
[01:28:11.454]                             hostname = base::Sys.info()[["nodename"]])
[01:28:11.454]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.454]                             info)
[01:28:11.454]                           info <- base::paste(info, collapse = "; ")
[01:28:11.454]                           if (!has_future) {
[01:28:11.454]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.454]                               info)
[01:28:11.454]                           }
[01:28:11.454]                           else {
[01:28:11.454]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.454]                               info, version)
[01:28:11.454]                           }
[01:28:11.454]                           base::stop(msg)
[01:28:11.454]                         }
[01:28:11.454]                       })
[01:28:11.454]                     }
[01:28:11.454]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.454]                     base::options(mc.cores = 1L)
[01:28:11.454]                   }
[01:28:11.454]                   options(future.plan = NULL)
[01:28:11.454]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.454]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.454]                 }
[01:28:11.454]                 ...future.workdir <- getwd()
[01:28:11.454]             }
[01:28:11.454]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.454]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.454]         }
[01:28:11.454]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.454]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.454]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.454]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.454]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.454]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.454]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.454]             base::names(...future.oldOptions))
[01:28:11.454]     }
[01:28:11.454]     if (FALSE) {
[01:28:11.454]     }
[01:28:11.454]     else {
[01:28:11.454]         if (TRUE) {
[01:28:11.454]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.454]                 open = "w")
[01:28:11.454]         }
[01:28:11.454]         else {
[01:28:11.454]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.454]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.454]         }
[01:28:11.454]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.454]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.454]             base::sink(type = "output", split = FALSE)
[01:28:11.454]             base::close(...future.stdout)
[01:28:11.454]         }, add = TRUE)
[01:28:11.454]     }
[01:28:11.454]     ...future.frame <- base::sys.nframe()
[01:28:11.454]     ...future.conditions <- base::list()
[01:28:11.454]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.454]     if (FALSE) {
[01:28:11.454]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.454]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.454]     }
[01:28:11.454]     ...future.result <- base::tryCatch({
[01:28:11.454]         base::withCallingHandlers({
[01:28:11.454]             ...future.value <- base::withVisible(base::local({
[01:28:11.454]                 ...future.makeSendCondition <- base::local({
[01:28:11.454]                   sendCondition <- NULL
[01:28:11.454]                   function(frame = 1L) {
[01:28:11.454]                     if (is.function(sendCondition)) 
[01:28:11.454]                       return(sendCondition)
[01:28:11.454]                     ns <- getNamespace("parallel")
[01:28:11.454]                     if (exists("sendData", mode = "function", 
[01:28:11.454]                       envir = ns)) {
[01:28:11.454]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.454]                         envir = ns)
[01:28:11.454]                       envir <- sys.frame(frame)
[01:28:11.454]                       master <- NULL
[01:28:11.454]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.454]                         !identical(envir, emptyenv())) {
[01:28:11.454]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.454]                           inherits = FALSE)) {
[01:28:11.454]                           master <- get("master", mode = "list", 
[01:28:11.454]                             envir = envir, inherits = FALSE)
[01:28:11.454]                           if (inherits(master, c("SOCKnode", 
[01:28:11.454]                             "SOCK0node"))) {
[01:28:11.454]                             sendCondition <<- function(cond) {
[01:28:11.454]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.454]                                 success = TRUE)
[01:28:11.454]                               parallel_sendData(master, data)
[01:28:11.454]                             }
[01:28:11.454]                             return(sendCondition)
[01:28:11.454]                           }
[01:28:11.454]                         }
[01:28:11.454]                         frame <- frame + 1L
[01:28:11.454]                         envir <- sys.frame(frame)
[01:28:11.454]                       }
[01:28:11.454]                     }
[01:28:11.454]                     sendCondition <<- function(cond) NULL
[01:28:11.454]                   }
[01:28:11.454]                 })
[01:28:11.454]                 withCallingHandlers({
[01:28:11.454]                   {
[01:28:11.454]                     x <- x + 1
[01:28:11.454]                     x
[01:28:11.454]                   }
[01:28:11.454]                 }, immediateCondition = function(cond) {
[01:28:11.454]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.454]                   sendCondition(cond)
[01:28:11.454]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.454]                   {
[01:28:11.454]                     inherits <- base::inherits
[01:28:11.454]                     invokeRestart <- base::invokeRestart
[01:28:11.454]                     is.null <- base::is.null
[01:28:11.454]                     muffled <- FALSE
[01:28:11.454]                     if (inherits(cond, "message")) {
[01:28:11.454]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.454]                       if (muffled) 
[01:28:11.454]                         invokeRestart("muffleMessage")
[01:28:11.454]                     }
[01:28:11.454]                     else if (inherits(cond, "warning")) {
[01:28:11.454]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.454]                       if (muffled) 
[01:28:11.454]                         invokeRestart("muffleWarning")
[01:28:11.454]                     }
[01:28:11.454]                     else if (inherits(cond, "condition")) {
[01:28:11.454]                       if (!is.null(pattern)) {
[01:28:11.454]                         computeRestarts <- base::computeRestarts
[01:28:11.454]                         grepl <- base::grepl
[01:28:11.454]                         restarts <- computeRestarts(cond)
[01:28:11.454]                         for (restart in restarts) {
[01:28:11.454]                           name <- restart$name
[01:28:11.454]                           if (is.null(name)) 
[01:28:11.454]                             next
[01:28:11.454]                           if (!grepl(pattern, name)) 
[01:28:11.454]                             next
[01:28:11.454]                           invokeRestart(restart)
[01:28:11.454]                           muffled <- TRUE
[01:28:11.454]                           break
[01:28:11.454]                         }
[01:28:11.454]                       }
[01:28:11.454]                     }
[01:28:11.454]                     invisible(muffled)
[01:28:11.454]                   }
[01:28:11.454]                   muffleCondition(cond)
[01:28:11.454]                 })
[01:28:11.454]             }))
[01:28:11.454]             future::FutureResult(value = ...future.value$value, 
[01:28:11.454]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.454]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.454]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.454]                     ...future.globalenv.names))
[01:28:11.454]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.454]         }, condition = base::local({
[01:28:11.454]             c <- base::c
[01:28:11.454]             inherits <- base::inherits
[01:28:11.454]             invokeRestart <- base::invokeRestart
[01:28:11.454]             length <- base::length
[01:28:11.454]             list <- base::list
[01:28:11.454]             seq.int <- base::seq.int
[01:28:11.454]             signalCondition <- base::signalCondition
[01:28:11.454]             sys.calls <- base::sys.calls
[01:28:11.454]             `[[` <- base::`[[`
[01:28:11.454]             `+` <- base::`+`
[01:28:11.454]             `<<-` <- base::`<<-`
[01:28:11.454]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.454]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.454]                   3L)]
[01:28:11.454]             }
[01:28:11.454]             function(cond) {
[01:28:11.454]                 is_error <- inherits(cond, "error")
[01:28:11.454]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.454]                   NULL)
[01:28:11.454]                 if (is_error) {
[01:28:11.454]                   sessionInformation <- function() {
[01:28:11.454]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.454]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.454]                       search = base::search(), system = base::Sys.info())
[01:28:11.454]                   }
[01:28:11.454]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.454]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.454]                     cond$call), session = sessionInformation(), 
[01:28:11.454]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.454]                   signalCondition(cond)
[01:28:11.454]                 }
[01:28:11.454]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.454]                 "immediateCondition"))) {
[01:28:11.454]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.454]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.454]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.454]                   if (TRUE && !signal) {
[01:28:11.454]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.454]                     {
[01:28:11.454]                       inherits <- base::inherits
[01:28:11.454]                       invokeRestart <- base::invokeRestart
[01:28:11.454]                       is.null <- base::is.null
[01:28:11.454]                       muffled <- FALSE
[01:28:11.454]                       if (inherits(cond, "message")) {
[01:28:11.454]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.454]                         if (muffled) 
[01:28:11.454]                           invokeRestart("muffleMessage")
[01:28:11.454]                       }
[01:28:11.454]                       else if (inherits(cond, "warning")) {
[01:28:11.454]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.454]                         if (muffled) 
[01:28:11.454]                           invokeRestart("muffleWarning")
[01:28:11.454]                       }
[01:28:11.454]                       else if (inherits(cond, "condition")) {
[01:28:11.454]                         if (!is.null(pattern)) {
[01:28:11.454]                           computeRestarts <- base::computeRestarts
[01:28:11.454]                           grepl <- base::grepl
[01:28:11.454]                           restarts <- computeRestarts(cond)
[01:28:11.454]                           for (restart in restarts) {
[01:28:11.454]                             name <- restart$name
[01:28:11.454]                             if (is.null(name)) 
[01:28:11.454]                               next
[01:28:11.454]                             if (!grepl(pattern, name)) 
[01:28:11.454]                               next
[01:28:11.454]                             invokeRestart(restart)
[01:28:11.454]                             muffled <- TRUE
[01:28:11.454]                             break
[01:28:11.454]                           }
[01:28:11.454]                         }
[01:28:11.454]                       }
[01:28:11.454]                       invisible(muffled)
[01:28:11.454]                     }
[01:28:11.454]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.454]                   }
[01:28:11.454]                 }
[01:28:11.454]                 else {
[01:28:11.454]                   if (TRUE) {
[01:28:11.454]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.454]                     {
[01:28:11.454]                       inherits <- base::inherits
[01:28:11.454]                       invokeRestart <- base::invokeRestart
[01:28:11.454]                       is.null <- base::is.null
[01:28:11.454]                       muffled <- FALSE
[01:28:11.454]                       if (inherits(cond, "message")) {
[01:28:11.454]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.454]                         if (muffled) 
[01:28:11.454]                           invokeRestart("muffleMessage")
[01:28:11.454]                       }
[01:28:11.454]                       else if (inherits(cond, "warning")) {
[01:28:11.454]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.454]                         if (muffled) 
[01:28:11.454]                           invokeRestart("muffleWarning")
[01:28:11.454]                       }
[01:28:11.454]                       else if (inherits(cond, "condition")) {
[01:28:11.454]                         if (!is.null(pattern)) {
[01:28:11.454]                           computeRestarts <- base::computeRestarts
[01:28:11.454]                           grepl <- base::grepl
[01:28:11.454]                           restarts <- computeRestarts(cond)
[01:28:11.454]                           for (restart in restarts) {
[01:28:11.454]                             name <- restart$name
[01:28:11.454]                             if (is.null(name)) 
[01:28:11.454]                               next
[01:28:11.454]                             if (!grepl(pattern, name)) 
[01:28:11.454]                               next
[01:28:11.454]                             invokeRestart(restart)
[01:28:11.454]                             muffled <- TRUE
[01:28:11.454]                             break
[01:28:11.454]                           }
[01:28:11.454]                         }
[01:28:11.454]                       }
[01:28:11.454]                       invisible(muffled)
[01:28:11.454]                     }
[01:28:11.454]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.454]                   }
[01:28:11.454]                 }
[01:28:11.454]             }
[01:28:11.454]         }))
[01:28:11.454]     }, error = function(ex) {
[01:28:11.454]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.454]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.454]                 ...future.rng), started = ...future.startTime, 
[01:28:11.454]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.454]             version = "1.8"), class = "FutureResult")
[01:28:11.454]     }, finally = {
[01:28:11.454]         if (!identical(...future.workdir, getwd())) 
[01:28:11.454]             setwd(...future.workdir)
[01:28:11.454]         {
[01:28:11.454]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.454]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.454]             }
[01:28:11.454]             base::options(...future.oldOptions)
[01:28:11.454]             if (.Platform$OS.type == "windows") {
[01:28:11.454]                 old_names <- names(...future.oldEnvVars)
[01:28:11.454]                 envs <- base::Sys.getenv()
[01:28:11.454]                 names <- names(envs)
[01:28:11.454]                 common <- intersect(names, old_names)
[01:28:11.454]                 added <- setdiff(names, old_names)
[01:28:11.454]                 removed <- setdiff(old_names, names)
[01:28:11.454]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.454]                   envs[common]]
[01:28:11.454]                 NAMES <- toupper(changed)
[01:28:11.454]                 args <- list()
[01:28:11.454]                 for (kk in seq_along(NAMES)) {
[01:28:11.454]                   name <- changed[[kk]]
[01:28:11.454]                   NAME <- NAMES[[kk]]
[01:28:11.454]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.454]                     next
[01:28:11.454]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.454]                 }
[01:28:11.454]                 NAMES <- toupper(added)
[01:28:11.454]                 for (kk in seq_along(NAMES)) {
[01:28:11.454]                   name <- added[[kk]]
[01:28:11.454]                   NAME <- NAMES[[kk]]
[01:28:11.454]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.454]                     next
[01:28:11.454]                   args[[name]] <- ""
[01:28:11.454]                 }
[01:28:11.454]                 NAMES <- toupper(removed)
[01:28:11.454]                 for (kk in seq_along(NAMES)) {
[01:28:11.454]                   name <- removed[[kk]]
[01:28:11.454]                   NAME <- NAMES[[kk]]
[01:28:11.454]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.454]                     next
[01:28:11.454]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.454]                 }
[01:28:11.454]                 if (length(args) > 0) 
[01:28:11.454]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.454]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.454]             }
[01:28:11.454]             else {
[01:28:11.454]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.454]             }
[01:28:11.454]             {
[01:28:11.454]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.454]                   0L) {
[01:28:11.454]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.454]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.454]                   base::options(opts)
[01:28:11.454]                 }
[01:28:11.454]                 {
[01:28:11.454]                   {
[01:28:11.454]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.454]                     NULL
[01:28:11.454]                   }
[01:28:11.454]                   options(future.plan = NULL)
[01:28:11.454]                   if (is.na(NA_character_)) 
[01:28:11.454]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.454]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.454]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.454]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.454]                     envir = parent.frame()) 
[01:28:11.454]                   {
[01:28:11.454]                     if (is.function(workers)) 
[01:28:11.454]                       workers <- workers()
[01:28:11.454]                     workers <- structure(as.integer(workers), 
[01:28:11.454]                       class = class(workers))
[01:28:11.454]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.454]                       workers >= 1)
[01:28:11.454]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.454]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.454]                     }
[01:28:11.454]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.454]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.454]                       envir = envir)
[01:28:11.454]                     if (!future$lazy) 
[01:28:11.454]                       future <- run(future)
[01:28:11.454]                     invisible(future)
[01:28:11.454]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.454]                 }
[01:28:11.454]             }
[01:28:11.454]         }
[01:28:11.454]     })
[01:28:11.454]     if (TRUE) {
[01:28:11.454]         base::sink(type = "output", split = FALSE)
[01:28:11.454]         if (TRUE) {
[01:28:11.454]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.454]         }
[01:28:11.454]         else {
[01:28:11.454]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.454]         }
[01:28:11.454]         base::close(...future.stdout)
[01:28:11.454]         ...future.stdout <- NULL
[01:28:11.454]     }
[01:28:11.454]     ...future.result$conditions <- ...future.conditions
[01:28:11.454]     ...future.result$finished <- base::Sys.time()
[01:28:11.454]     ...future.result
[01:28:11.454] }
[01:28:11.462] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:28:11.463] Exporting 'x' (56 bytes) to cluster node #1 ...
[01:28:11.463] Exporting 'x' (56 bytes) to cluster node #1 ... DONE
[01:28:11.463] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:28:11.464] MultisessionFuture started
[01:28:11.464] - Launch lazy future ... done
[01:28:11.464] run() for 'MultisessionFuture' ... done
[01:28:11.465] result() for ClusterFuture ...
[01:28:11.465] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.465] - Validating connection of MultisessionFuture
[01:28:11.482] - received message: FutureResult
[01:28:11.482] - Received FutureResult
[01:28:11.482] - Erased future from FutureRegistry
[01:28:11.483] result() for ClusterFuture ...
[01:28:11.483] - result already collected: FutureResult
[01:28:11.483] result() for ClusterFuture ... done
[01:28:11.483] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.483] result() for ClusterFuture ... done
[01:28:11.483] result() for ClusterFuture ...
[01:28:11.484] - result already collected: FutureResult
[01:28:11.484] result() for ClusterFuture ... done
value(f) = '2'
Warning: R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[01:28:11.484] getGlobalsAndPackages() ...
Warning: R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[01:28:11.485] Searching for globals...
Warning: R option 'future.globals.method' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'ordered'
[01:28:11.487] - globals found: [3] '{', '<-', 'x'
[01:28:11.487] Searching for globals ... DONE
[01:28:11.487] Resolving globals: TRUE
[01:28:11.487] Resolving any globals that are futures ...
[01:28:11.488] - globals: [3] '{', '<-', 'x'
[01:28:11.488] Resolving any globals that are futures ... DONE
[01:28:11.488] Resolving futures part of globals (recursively) ...
[01:28:11.489] resolve() on list ...
[01:28:11.489]  recursive: 99
[01:28:11.489]  length: 1
[01:28:11.489]  elements: 'x'
[01:28:11.489]  length: 0 (resolved future 1)
[01:28:11.490] resolve() on list ... DONE
[01:28:11.490] - globals: [1] 'x'
[01:28:11.490] Resolving futures part of globals (recursively) ... DONE
[01:28:11.490] The total size of the 1 globals is 1.01 KiB (1032 bytes)
[01:28:11.491] The total size of the 1 globals exported for future expression ('{; x <- x(); x; }') is 1.01 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (1.01 KiB of class 'function')
[01:28:11.491] - globals: [1] 'x'
[01:28:11.491] 
[01:28:11.491] getGlobalsAndPackages() ... DONE
[01:28:11.492] run() for 'Future' ...
[01:28:11.492] - state: 'created'
[01:28:11.492] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:11.508] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:11.508] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:11.509]   - Field: 'node'
[01:28:11.509]   - Field: 'label'
[01:28:11.509]   - Field: 'local'
[01:28:11.510]   - Field: 'owner'
[01:28:11.510]   - Field: 'envir'
[01:28:11.510]   - Field: 'workers'
[01:28:11.510]   - Field: 'packages'
[01:28:11.511]   - Field: 'gc'
[01:28:11.511]   - Field: 'conditions'
[01:28:11.511]   - Field: 'persistent'
[01:28:11.511]   - Field: 'expr'
[01:28:11.511]   - Field: 'uuid'
[01:28:11.512]   - Field: 'seed'
[01:28:11.512]   - Field: 'version'
[01:28:11.512]   - Field: 'result'
[01:28:11.512]   - Field: 'asynchronous'
[01:28:11.512]   - Field: 'calls'
[01:28:11.512]   - Field: 'globals'
[01:28:11.513]   - Field: 'stdout'
[01:28:11.513]   - Field: 'earlySignal'
[01:28:11.513]   - Field: 'lazy'
[01:28:11.513]   - Field: 'state'
[01:28:11.513] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:11.513] - Launch lazy future ...
[01:28:11.514] Packages needed by the future expression (n = 0): <none>
[01:28:11.514] Packages needed by future strategies (n = 0): <none>
[01:28:11.515] {
[01:28:11.515]     {
[01:28:11.515]         {
[01:28:11.515]             ...future.startTime <- base::Sys.time()
[01:28:11.515]             {
[01:28:11.515]                 {
[01:28:11.515]                   {
[01:28:11.515]                     {
[01:28:11.515]                       base::local({
[01:28:11.515]                         has_future <- base::requireNamespace("future", 
[01:28:11.515]                           quietly = TRUE)
[01:28:11.515]                         if (has_future) {
[01:28:11.515]                           ns <- base::getNamespace("future")
[01:28:11.515]                           version <- ns[[".package"]][["version"]]
[01:28:11.515]                           if (is.null(version)) 
[01:28:11.515]                             version <- utils::packageVersion("future")
[01:28:11.515]                         }
[01:28:11.515]                         else {
[01:28:11.515]                           version <- NULL
[01:28:11.515]                         }
[01:28:11.515]                         if (!has_future || version < "1.8.0") {
[01:28:11.515]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:11.515]                             "", base::R.version$version.string), 
[01:28:11.515]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:11.515]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:11.515]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:11.515]                               "release", "version")], collapse = " "), 
[01:28:11.515]                             hostname = base::Sys.info()[["nodename"]])
[01:28:11.515]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:11.515]                             info)
[01:28:11.515]                           info <- base::paste(info, collapse = "; ")
[01:28:11.515]                           if (!has_future) {
[01:28:11.515]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:11.515]                               info)
[01:28:11.515]                           }
[01:28:11.515]                           else {
[01:28:11.515]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:11.515]                               info, version)
[01:28:11.515]                           }
[01:28:11.515]                           base::stop(msg)
[01:28:11.515]                         }
[01:28:11.515]                       })
[01:28:11.515]                     }
[01:28:11.515]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:11.515]                     base::options(mc.cores = 1L)
[01:28:11.515]                   }
[01:28:11.515]                   options(future.plan = NULL)
[01:28:11.515]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.515]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:11.515]                 }
[01:28:11.515]                 ...future.workdir <- getwd()
[01:28:11.515]             }
[01:28:11.515]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:11.515]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:11.515]         }
[01:28:11.515]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:11.515]             future.globals.maxSize = NULL, future.globals.method = "ordered", 
[01:28:11.515]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:11.515]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:11.515]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:11.515]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:11.515]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:11.515]             base::names(...future.oldOptions))
[01:28:11.515]     }
[01:28:11.515]     if (FALSE) {
[01:28:11.515]     }
[01:28:11.515]     else {
[01:28:11.515]         if (TRUE) {
[01:28:11.515]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:11.515]                 open = "w")
[01:28:11.515]         }
[01:28:11.515]         else {
[01:28:11.515]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:11.515]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:11.515]         }
[01:28:11.515]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:11.515]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:11.515]             base::sink(type = "output", split = FALSE)
[01:28:11.515]             base::close(...future.stdout)
[01:28:11.515]         }, add = TRUE)
[01:28:11.515]     }
[01:28:11.515]     ...future.frame <- base::sys.nframe()
[01:28:11.515]     ...future.conditions <- base::list()
[01:28:11.515]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:11.515]     if (FALSE) {
[01:28:11.515]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:11.515]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:11.515]     }
[01:28:11.515]     ...future.result <- base::tryCatch({
[01:28:11.515]         base::withCallingHandlers({
[01:28:11.515]             ...future.value <- base::withVisible(base::local({
[01:28:11.515]                 ...future.makeSendCondition <- base::local({
[01:28:11.515]                   sendCondition <- NULL
[01:28:11.515]                   function(frame = 1L) {
[01:28:11.515]                     if (is.function(sendCondition)) 
[01:28:11.515]                       return(sendCondition)
[01:28:11.515]                     ns <- getNamespace("parallel")
[01:28:11.515]                     if (exists("sendData", mode = "function", 
[01:28:11.515]                       envir = ns)) {
[01:28:11.515]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:11.515]                         envir = ns)
[01:28:11.515]                       envir <- sys.frame(frame)
[01:28:11.515]                       master <- NULL
[01:28:11.515]                       while (!identical(envir, .GlobalEnv) && 
[01:28:11.515]                         !identical(envir, emptyenv())) {
[01:28:11.515]                         if (exists("master", mode = "list", envir = envir, 
[01:28:11.515]                           inherits = FALSE)) {
[01:28:11.515]                           master <- get("master", mode = "list", 
[01:28:11.515]                             envir = envir, inherits = FALSE)
[01:28:11.515]                           if (inherits(master, c("SOCKnode", 
[01:28:11.515]                             "SOCK0node"))) {
[01:28:11.515]                             sendCondition <<- function(cond) {
[01:28:11.515]                               data <- list(type = "VALUE", value = cond, 
[01:28:11.515]                                 success = TRUE)
[01:28:11.515]                               parallel_sendData(master, data)
[01:28:11.515]                             }
[01:28:11.515]                             return(sendCondition)
[01:28:11.515]                           }
[01:28:11.515]                         }
[01:28:11.515]                         frame <- frame + 1L
[01:28:11.515]                         envir <- sys.frame(frame)
[01:28:11.515]                       }
[01:28:11.515]                     }
[01:28:11.515]                     sendCondition <<- function(cond) NULL
[01:28:11.515]                   }
[01:28:11.515]                 })
[01:28:11.515]                 withCallingHandlers({
[01:28:11.515]                   {
[01:28:11.515]                     x <- x()
[01:28:11.515]                     x
[01:28:11.515]                   }
[01:28:11.515]                 }, immediateCondition = function(cond) {
[01:28:11.515]                   sendCondition <- ...future.makeSendCondition()
[01:28:11.515]                   sendCondition(cond)
[01:28:11.515]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.515]                   {
[01:28:11.515]                     inherits <- base::inherits
[01:28:11.515]                     invokeRestart <- base::invokeRestart
[01:28:11.515]                     is.null <- base::is.null
[01:28:11.515]                     muffled <- FALSE
[01:28:11.515]                     if (inherits(cond, "message")) {
[01:28:11.515]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:11.515]                       if (muffled) 
[01:28:11.515]                         invokeRestart("muffleMessage")
[01:28:11.515]                     }
[01:28:11.515]                     else if (inherits(cond, "warning")) {
[01:28:11.515]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:11.515]                       if (muffled) 
[01:28:11.515]                         invokeRestart("muffleWarning")
[01:28:11.515]                     }
[01:28:11.515]                     else if (inherits(cond, "condition")) {
[01:28:11.515]                       if (!is.null(pattern)) {
[01:28:11.515]                         computeRestarts <- base::computeRestarts
[01:28:11.515]                         grepl <- base::grepl
[01:28:11.515]                         restarts <- computeRestarts(cond)
[01:28:11.515]                         for (restart in restarts) {
[01:28:11.515]                           name <- restart$name
[01:28:11.515]                           if (is.null(name)) 
[01:28:11.515]                             next
[01:28:11.515]                           if (!grepl(pattern, name)) 
[01:28:11.515]                             next
[01:28:11.515]                           invokeRestart(restart)
[01:28:11.515]                           muffled <- TRUE
[01:28:11.515]                           break
[01:28:11.515]                         }
[01:28:11.515]                       }
[01:28:11.515]                     }
[01:28:11.515]                     invisible(muffled)
[01:28:11.515]                   }
[01:28:11.515]                   muffleCondition(cond)
[01:28:11.515]                 })
[01:28:11.515]             }))
[01:28:11.515]             future::FutureResult(value = ...future.value$value, 
[01:28:11.515]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.515]                   ...future.rng), globalenv = if (FALSE) 
[01:28:11.515]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:11.515]                     ...future.globalenv.names))
[01:28:11.515]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:11.515]         }, condition = base::local({
[01:28:11.515]             c <- base::c
[01:28:11.515]             inherits <- base::inherits
[01:28:11.515]             invokeRestart <- base::invokeRestart
[01:28:11.515]             length <- base::length
[01:28:11.515]             list <- base::list
[01:28:11.515]             seq.int <- base::seq.int
[01:28:11.515]             signalCondition <- base::signalCondition
[01:28:11.515]             sys.calls <- base::sys.calls
[01:28:11.515]             `[[` <- base::`[[`
[01:28:11.515]             `+` <- base::`+`
[01:28:11.515]             `<<-` <- base::`<<-`
[01:28:11.515]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:11.515]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:11.515]                   3L)]
[01:28:11.515]             }
[01:28:11.515]             function(cond) {
[01:28:11.515]                 is_error <- inherits(cond, "error")
[01:28:11.515]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:11.515]                   NULL)
[01:28:11.515]                 if (is_error) {
[01:28:11.515]                   sessionInformation <- function() {
[01:28:11.515]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:11.515]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:11.515]                       search = base::search(), system = base::Sys.info())
[01:28:11.515]                   }
[01:28:11.515]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.515]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:11.515]                     cond$call), session = sessionInformation(), 
[01:28:11.515]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:11.515]                   signalCondition(cond)
[01:28:11.515]                 }
[01:28:11.515]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:11.515]                 "immediateCondition"))) {
[01:28:11.515]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:11.515]                   ...future.conditions[[length(...future.conditions) + 
[01:28:11.515]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:11.515]                   if (TRUE && !signal) {
[01:28:11.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.515]                     {
[01:28:11.515]                       inherits <- base::inherits
[01:28:11.515]                       invokeRestart <- base::invokeRestart
[01:28:11.515]                       is.null <- base::is.null
[01:28:11.515]                       muffled <- FALSE
[01:28:11.515]                       if (inherits(cond, "message")) {
[01:28:11.515]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.515]                         if (muffled) 
[01:28:11.515]                           invokeRestart("muffleMessage")
[01:28:11.515]                       }
[01:28:11.515]                       else if (inherits(cond, "warning")) {
[01:28:11.515]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.515]                         if (muffled) 
[01:28:11.515]                           invokeRestart("muffleWarning")
[01:28:11.515]                       }
[01:28:11.515]                       else if (inherits(cond, "condition")) {
[01:28:11.515]                         if (!is.null(pattern)) {
[01:28:11.515]                           computeRestarts <- base::computeRestarts
[01:28:11.515]                           grepl <- base::grepl
[01:28:11.515]                           restarts <- computeRestarts(cond)
[01:28:11.515]                           for (restart in restarts) {
[01:28:11.515]                             name <- restart$name
[01:28:11.515]                             if (is.null(name)) 
[01:28:11.515]                               next
[01:28:11.515]                             if (!grepl(pattern, name)) 
[01:28:11.515]                               next
[01:28:11.515]                             invokeRestart(restart)
[01:28:11.515]                             muffled <- TRUE
[01:28:11.515]                             break
[01:28:11.515]                           }
[01:28:11.515]                         }
[01:28:11.515]                       }
[01:28:11.515]                       invisible(muffled)
[01:28:11.515]                     }
[01:28:11.515]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.515]                   }
[01:28:11.515]                 }
[01:28:11.515]                 else {
[01:28:11.515]                   if (TRUE) {
[01:28:11.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:11.515]                     {
[01:28:11.515]                       inherits <- base::inherits
[01:28:11.515]                       invokeRestart <- base::invokeRestart
[01:28:11.515]                       is.null <- base::is.null
[01:28:11.515]                       muffled <- FALSE
[01:28:11.515]                       if (inherits(cond, "message")) {
[01:28:11.515]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:11.515]                         if (muffled) 
[01:28:11.515]                           invokeRestart("muffleMessage")
[01:28:11.515]                       }
[01:28:11.515]                       else if (inherits(cond, "warning")) {
[01:28:11.515]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:11.515]                         if (muffled) 
[01:28:11.515]                           invokeRestart("muffleWarning")
[01:28:11.515]                       }
[01:28:11.515]                       else if (inherits(cond, "condition")) {
[01:28:11.515]                         if (!is.null(pattern)) {
[01:28:11.515]                           computeRestarts <- base::computeRestarts
[01:28:11.515]                           grepl <- base::grepl
[01:28:11.515]                           restarts <- computeRestarts(cond)
[01:28:11.515]                           for (restart in restarts) {
[01:28:11.515]                             name <- restart$name
[01:28:11.515]                             if (is.null(name)) 
[01:28:11.515]                               next
[01:28:11.515]                             if (!grepl(pattern, name)) 
[01:28:11.515]                               next
[01:28:11.515]                             invokeRestart(restart)
[01:28:11.515]                             muffled <- TRUE
[01:28:11.515]                             break
[01:28:11.515]                           }
[01:28:11.515]                         }
[01:28:11.515]                       }
[01:28:11.515]                       invisible(muffled)
[01:28:11.515]                     }
[01:28:11.515]                     muffleCondition(cond, pattern = "^muffle")
[01:28:11.515]                   }
[01:28:11.515]                 }
[01:28:11.515]             }
[01:28:11.515]         }))
[01:28:11.515]     }, error = function(ex) {
[01:28:11.515]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:11.515]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:11.515]                 ...future.rng), started = ...future.startTime, 
[01:28:11.515]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:11.515]             version = "1.8"), class = "FutureResult")
[01:28:11.515]     }, finally = {
[01:28:11.515]         if (!identical(...future.workdir, getwd())) 
[01:28:11.515]             setwd(...future.workdir)
[01:28:11.515]         {
[01:28:11.515]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:11.515]                 ...future.oldOptions$nwarnings <- NULL
[01:28:11.515]             }
[01:28:11.515]             base::options(...future.oldOptions)
[01:28:11.515]             if (.Platform$OS.type == "windows") {
[01:28:11.515]                 old_names <- names(...future.oldEnvVars)
[01:28:11.515]                 envs <- base::Sys.getenv()
[01:28:11.515]                 names <- names(envs)
[01:28:11.515]                 common <- intersect(names, old_names)
[01:28:11.515]                 added <- setdiff(names, old_names)
[01:28:11.515]                 removed <- setdiff(old_names, names)
[01:28:11.515]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:11.515]                   envs[common]]
[01:28:11.515]                 NAMES <- toupper(changed)
[01:28:11.515]                 args <- list()
[01:28:11.515]                 for (kk in seq_along(NAMES)) {
[01:28:11.515]                   name <- changed[[kk]]
[01:28:11.515]                   NAME <- NAMES[[kk]]
[01:28:11.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.515]                     next
[01:28:11.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.515]                 }
[01:28:11.515]                 NAMES <- toupper(added)
[01:28:11.515]                 for (kk in seq_along(NAMES)) {
[01:28:11.515]                   name <- added[[kk]]
[01:28:11.515]                   NAME <- NAMES[[kk]]
[01:28:11.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.515]                     next
[01:28:11.515]                   args[[name]] <- ""
[01:28:11.515]                 }
[01:28:11.515]                 NAMES <- toupper(removed)
[01:28:11.515]                 for (kk in seq_along(NAMES)) {
[01:28:11.515]                   name <- removed[[kk]]
[01:28:11.515]                   NAME <- NAMES[[kk]]
[01:28:11.515]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:11.515]                     next
[01:28:11.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:11.515]                 }
[01:28:11.515]                 if (length(args) > 0) 
[01:28:11.515]                   base::do.call(base::Sys.setenv, args = args)
[01:28:11.515]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:11.515]             }
[01:28:11.515]             else {
[01:28:11.515]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:11.515]             }
[01:28:11.515]             {
[01:28:11.515]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:11.515]                   0L) {
[01:28:11.515]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:11.515]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:11.515]                   base::options(opts)
[01:28:11.515]                 }
[01:28:11.515]                 {
[01:28:11.515]                   {
[01:28:11.515]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:11.515]                     NULL
[01:28:11.515]                   }
[01:28:11.515]                   options(future.plan = NULL)
[01:28:11.515]                   if (is.na(NA_character_)) 
[01:28:11.515]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:11.515]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:11.515]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:11.515]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:11.515]                     envir = parent.frame()) 
[01:28:11.515]                   {
[01:28:11.515]                     if (is.function(workers)) 
[01:28:11.515]                       workers <- workers()
[01:28:11.515]                     workers <- structure(as.integer(workers), 
[01:28:11.515]                       class = class(workers))
[01:28:11.515]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:11.515]                       workers >= 1)
[01:28:11.515]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:11.515]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:11.515]                     }
[01:28:11.515]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:11.515]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:11.515]                       envir = envir)
[01:28:11.515]                     if (!future$lazy) 
[01:28:11.515]                       future <- run(future)
[01:28:11.515]                     invisible(future)
[01:28:11.515]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:11.515]                 }
[01:28:11.515]             }
[01:28:11.515]         }
[01:28:11.515]     })
[01:28:11.515]     if (TRUE) {
[01:28:11.515]         base::sink(type = "output", split = FALSE)
[01:28:11.515]         if (TRUE) {
[01:28:11.515]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:11.515]         }
[01:28:11.515]         else {
[01:28:11.515]             ...future.result["stdout"] <- base::list(NULL)
[01:28:11.515]         }
[01:28:11.515]         base::close(...future.stdout)
[01:28:11.515]         ...future.stdout <- NULL
[01:28:11.515]     }
[01:28:11.515]     ...future.result$conditions <- ...future.conditions
[01:28:11.515]     ...future.result$finished <- base::Sys.time()
[01:28:11.515]     ...future.result
[01:28:11.515] }
[01:28:11.520] Exporting 1 global objects (1.01 KiB) to cluster node #1 ...
[01:28:11.521] Exporting 'x' (1.01 KiB) to cluster node #1 ...
[01:28:11.521] Exporting 'x' (1.01 KiB) to cluster node #1 ... DONE
[01:28:11.521] Exporting 1 global objects (1.01 KiB) to cluster node #1 ... DONE
[01:28:11.522] MultisessionFuture started
[01:28:11.522] - Launch lazy future ... done
[01:28:11.522] run() for 'MultisessionFuture' ... done
[01:28:11.522] result() for ClusterFuture ...
[01:28:11.523] receiveMessageFromWorker() for ClusterFuture ...
[01:28:11.523] - Validating connection of MultisessionFuture
[01:28:11.563] - received message: FutureResult
[01:28:11.563] - Received FutureResult
[01:28:11.564] - Erased future from FutureRegistry
[01:28:11.564] result() for ClusterFuture ...
[01:28:11.564] - result already collected: FutureResult
[01:28:11.564] result() for ClusterFuture ... done
[01:28:11.564] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:11.564] result() for ClusterFuture ... done
[01:28:11.565] result() for ClusterFuture ...
[01:28:11.565] - result already collected: FutureResult
[01:28:11.565] result() for ClusterFuture ... done
value(f) = 'TRUE'
Testing with 2 cores ... DONE
> 
> message("*** Tricky use cases related to globals ... DONE")
*** Tricky use cases related to globals ... DONE
> 
> source("incl/end.R")
[01:28:11.566] plan(): Setting new future strategy stack:
[01:28:11.566] List of future strategies:
[01:28:11.566] 1. FutureStrategy:
[01:28:11.566]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:11.566]    - tweaked: FALSE
[01:28:11.566]    - call: future::plan(oplan)
[01:28:11.568] 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 
   2.95    0.10    4.26