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

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

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

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

> source("incl/start.R")
[17:28:38.897] plan(): Setting new future strategy stack:
[17:28:38.900] List of future strategies:
[17:28:38.900] 1. sequential:
[17:28:38.900]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:38.900]    - tweaked: FALSE
[17:28:38.900]    - call: future::plan("sequential")
[17:28:38.918] plan(): nbrOfWorkers() = 1
> 
> strategies <- supportedStrategies()
> 
> message("*** Nested futures ...")
*** Nested futures ...
> 
> for (strategy1 in strategies) {
+   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
+   if (!fullTest && isWin32) next
+   
+   for (strategy2 in strategies) {
+     message(sprintf("- plan(list('%s', '%s')) ...", strategy1, strategy2))
+     plan(list(a = strategy1, b = strategy2))
+     
+     nested <- plan("list")
+     stopifnot(
+       length(nested) == 2L,
+       all(names(nested) == c("a", "b")),
+       inherits(plan("next"), strategy1)
+     )
+ 
+     x %<-% {
+       a <- 1L
+ 
+       ## IMPORTANT: Use future::plan() - not just plan() - otherwise
+       ## we're exporting the plan() function including its local stack!
+       plan_a <- unclass(future::plan("list"))
+       nested_a <- nested[-1]
+ 
+       stopifnot(
+         length(nested_a) == 1L,
+         length(plan_a) == 1L,
+         inherits(plan_a[[1]], "future"),
+         inherits(future::plan("next"), strategy2)
+       )
+ 
+       ## Attribute 'init' is modified at run time
+       for (kk in seq_along(plan_a)) attr(plan_a[[kk]], "init") <- NULL
+       for (kk in seq_along(nested_a)) attr(nested_a[[kk]], "init") <- NULL
+       stopifnot(all.equal(plan_a, nested_a))
+ 
+       y %<-% {
+         b <- 2L
+         
+         ## IMPORTANT: Use future::plan() - not just plan() - otherwise
+         ## we're exporting the plan() function including its local stack!
+         plan_b <- future::plan("list")
+         nested_b <- nested_a[-1]
+ 
+         stopifnot(
+           length(nested_b) == 0L,
+           length(plan_b) == 1L,
+           inherits(plan_b[[1]], "future"),
+           inherits(future::plan("next"), "sequential")
+         )
+ 
+         list(a = a, nested_a = nested_a, plan_a = plan_a,
+              b = b, nested_b = nested_b, plan_b = plan_b)
+       }
+       y
+     }
+ 
+     str(x)
+ 
+     stopifnot(
+       length(x) == 3 * length(nested),
+       all(names(x) == c("a", "nested_a", "plan_a",
+                         "b", "nested_b", "plan_b")),
+ 
+       x$a == 1L,
+       length(x$nested_a) == 1L,
+       is.list(x$plan_a),
+       length(x$plan_a) == 1L,
+       inherits(x$plan_a[[1]], "future"),
+ 
+       x$b == 2L,
+       length(x$nested_b) == 0L,
+       is.list(x$plan_b),
+       length(x$plan_b) == 1L,
+       inherits(x$plan_b[[1]], "future"),
+       inherits(x$plan_b[[1]], "sequential")
+     )
+ 
+     ## Attribute 'init' is modified at run time
+     for (kk in seq_along(x$plan_a)) attr(x$plan_a[[kk]], "init") <- NULL
+     for (kk in seq_along(nested)) attr(nested[[kk]], "init") <- NULL
+     stopifnot(all.equal(x$plan_a, nested[-1L]))
+ 
+     rm(list = c("nested", "x"))
+ 
+ 
+     ## Nested futures and globals
+     ## In future (<= 1.7.0), the below would produce an error saying
+     ## "Failed to locate global object in the relevant environments: 'a'"
+     ## Related to https://github.com/HenrikBengtsson/globals/issues/35
+     data <- data.frame(a = 1:3, b = 3:1)
+     y_truth <- subset(data, a == 2)
+     f <- future({
+       value(future( subset(data, a == 2) ))
+     })
+     y <- value(f)
+     stopifnot(identical(y, y_truth))
+     
+     message(sprintf("- plan(list('%s', '%s')) ... DONE", strategy1, strategy2))
+   }
+ }
- plan(list('sequential', 'sequential')) ...
[17:28:38.994] plan(): Setting new future strategy stack:
[17:28:38.994] List of future strategies:
[17:28:38.994] 1. sequential:
[17:28:38.994]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:38.994]    - tweaked: FALSE
[17:28:38.994]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:38.994] 2. sequential:
[17:28:38.994]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:38.994]    - tweaked: FALSE
[17:28:38.994]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.021] plan(): nbrOfWorkers() = 1
[17:28:39.024] getGlobalsAndPackages() ...
[17:28:39.024] Searching for globals...
[17:28:39.076] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[17:28:39.077] Searching for globals ... DONE
[17:28:39.077] Resolving globals: FALSE
[17:28:39.080] The total size of the 2 globals is 3.28 KiB (3359 bytes)
[17:28:39.081] The total size of the 2 globals exported for future expression ('{; a <- 1L; plan_a <- unclass(future::plan("list")); nested_a <- nested[-1]; stopifnot(length(nested_a) == 1L, length(plan_a) == 1L, inherits(plan_a[[1]],; "future"), inherits(future::plan("next"), strategy2)); ...; }; y; }') is 3.28 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (3.23 KiB of class 'list') and 'strategy2' (49 bytes of class 'character')
[17:28:39.082] - globals: [2] 'nested', 'strategy2'
[17:28:39.082] - packages: [1] 'future'
[17:28:39.082] getGlobalsAndPackages() ... DONE
[17:28:39.084] run() for 'Future' ...
[17:28:39.084] - state: 'created'
[17:28:39.085] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:39.085] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:39.086] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:39.086]   - Field: 'label'
[17:28:39.087]   - Field: 'local'
[17:28:39.087]   - Field: 'owner'
[17:28:39.087]   - Field: 'envir'
[17:28:39.088]   - Field: 'packages'
[17:28:39.088]   - Field: 'gc'
[17:28:39.088]   - Field: 'conditions'
[17:28:39.088]   - Field: 'expr'
[17:28:39.089]   - Field: 'uuid'
[17:28:39.089]   - Field: 'seed'
[17:28:39.089]   - Field: 'version'
[17:28:39.090]   - Field: 'result'
[17:28:39.090]   - Field: 'asynchronous'
[17:28:39.090]   - Field: 'calls'
[17:28:39.091]   - Field: 'globals'
[17:28:39.091]   - Field: 'stdout'
[17:28:39.091]   - Field: 'earlySignal'
[17:28:39.092]   - Field: 'lazy'
[17:28:39.092]   - Field: 'state'
[17:28:39.092] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:39.093] - Launch lazy future ...
[17:28:39.094] Packages needed by the future expression (n = 1): 'future'
[17:28:39.095] Packages needed by future strategies (n = 1): 'future'
[17:28:39.097] {
[17:28:39.097]     {
[17:28:39.097]         {
[17:28:39.097]             ...future.startTime <- base::Sys.time()
[17:28:39.097]             {
[17:28:39.097]                 {
[17:28:39.097]                   {
[17:28:39.097]                     {
[17:28:39.097]                       base::local({
[17:28:39.097]                         has_future <- base::requireNamespace("future", 
[17:28:39.097]                           quietly = TRUE)
[17:28:39.097]                         if (has_future) {
[17:28:39.097]                           ns <- base::getNamespace("future")
[17:28:39.097]                           version <- ns[[".package"]][["version"]]
[17:28:39.097]                           if (is.null(version)) 
[17:28:39.097]                             version <- utils::packageVersion("future")
[17:28:39.097]                         }
[17:28:39.097]                         else {
[17:28:39.097]                           version <- NULL
[17:28:39.097]                         }
[17:28:39.097]                         if (!has_future || version < "1.8.0") {
[17:28:39.097]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:39.097]                             "", base::R.version$version.string), 
[17:28:39.097]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:39.097]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:39.097]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:39.097]                               "release", "version")], collapse = " "), 
[17:28:39.097]                             hostname = base::Sys.info()[["nodename"]])
[17:28:39.097]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:39.097]                             info)
[17:28:39.097]                           info <- base::paste(info, collapse = "; ")
[17:28:39.097]                           if (!has_future) {
[17:28:39.097]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:39.097]                               info)
[17:28:39.097]                           }
[17:28:39.097]                           else {
[17:28:39.097]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:39.097]                               info, version)
[17:28:39.097]                           }
[17:28:39.097]                           base::stop(msg)
[17:28:39.097]                         }
[17:28:39.097]                       })
[17:28:39.097]                     }
[17:28:39.097]                     base::local({
[17:28:39.097]                       for (pkg in "future") {
[17:28:39.097]                         base::loadNamespace(pkg)
[17:28:39.097]                         base::library(pkg, character.only = TRUE)
[17:28:39.097]                       }
[17:28:39.097]                     })
[17:28:39.097]                   }
[17:28:39.097]                   ...future.strategy.old <- future::plan("list")
[17:28:39.097]                   options(future.plan = NULL)
[17:28:39.097]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.097]                   future::plan(list(b = function (..., envir = parent.frame()) 
[17:28:39.097]                   {
[17:28:39.097]                     future <- SequentialFuture(..., envir = envir)
[17:28:39.097]                     if (!future$lazy) 
[17:28:39.097]                       future <- run(future)
[17:28:39.097]                     invisible(future)
[17:28:39.097]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:39.097]                 }
[17:28:39.097]                 ...future.workdir <- getwd()
[17:28:39.097]             }
[17:28:39.097]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:39.097]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:39.097]         }
[17:28:39.097]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:39.097]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:39.097]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:39.097]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:39.097]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:39.097]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:39.097]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:39.097]             base::names(...future.oldOptions))
[17:28:39.097]     }
[17:28:39.097]     if (FALSE) {
[17:28:39.097]     }
[17:28:39.097]     else {
[17:28:39.097]         if (TRUE) {
[17:28:39.097]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:39.097]                 open = "w")
[17:28:39.097]         }
[17:28:39.097]         else {
[17:28:39.097]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:39.097]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:39.097]         }
[17:28:39.097]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:39.097]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:39.097]             base::sink(type = "output", split = FALSE)
[17:28:39.097]             base::close(...future.stdout)
[17:28:39.097]         }, add = TRUE)
[17:28:39.097]     }
[17:28:39.097]     ...future.frame <- base::sys.nframe()
[17:28:39.097]     ...future.conditions <- base::list()
[17:28:39.097]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:39.097]     if (FALSE) {
[17:28:39.097]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:39.097]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:39.097]     }
[17:28:39.097]     ...future.result <- base::tryCatch({
[17:28:39.097]         base::withCallingHandlers({
[17:28:39.097]             ...future.value <- base::withVisible(base::local({
[17:28:39.097]                 a <- 1L
[17:28:39.097]                 plan_a <- unclass(future::plan("list"))
[17:28:39.097]                 nested_a <- nested[-1]
[17:28:39.097]                 stopifnot(length(nested_a) == 1L, length(plan_a) == 
[17:28:39.097]                   1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[17:28:39.097]                   strategy2))
[17:28:39.097]                 for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[17:28:39.097]                   "init") <- NULL
[17:28:39.097]                 for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[17:28:39.097]                   "init") <- NULL
[17:28:39.097]                 stopifnot(all.equal(plan_a, nested_a))
[17:28:39.097]                 y %<-% {
[17:28:39.097]                   b <- 2L
[17:28:39.097]                   plan_b <- future::plan("list")
[17:28:39.097]                   nested_b <- nested_a[-1]
[17:28:39.097]                   stopifnot(length(nested_b) == 0L, length(plan_b) == 
[17:28:39.097]                     1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[17:28:39.097]                     "sequential"))
[17:28:39.097]                   list(a = a, nested_a = nested_a, plan_a = plan_a, 
[17:28:39.097]                     b = b, nested_b = nested_b, plan_b = plan_b)
[17:28:39.097]                 }
[17:28:39.097]                 y
[17:28:39.097]             }))
[17:28:39.097]             future::FutureResult(value = ...future.value$value, 
[17:28:39.097]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.097]                   ...future.rng), globalenv = if (FALSE) 
[17:28:39.097]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:39.097]                     ...future.globalenv.names))
[17:28:39.097]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:39.097]         }, condition = base::local({
[17:28:39.097]             c <- base::c
[17:28:39.097]             inherits <- base::inherits
[17:28:39.097]             invokeRestart <- base::invokeRestart
[17:28:39.097]             length <- base::length
[17:28:39.097]             list <- base::list
[17:28:39.097]             seq.int <- base::seq.int
[17:28:39.097]             signalCondition <- base::signalCondition
[17:28:39.097]             sys.calls <- base::sys.calls
[17:28:39.097]             `[[` <- base::`[[`
[17:28:39.097]             `+` <- base::`+`
[17:28:39.097]             `<<-` <- base::`<<-`
[17:28:39.097]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:39.097]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:39.097]                   3L)]
[17:28:39.097]             }
[17:28:39.097]             function(cond) {
[17:28:39.097]                 is_error <- inherits(cond, "error")
[17:28:39.097]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:39.097]                   NULL)
[17:28:39.097]                 if (is_error) {
[17:28:39.097]                   sessionInformation <- function() {
[17:28:39.097]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:39.097]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:39.097]                       search = base::search(), system = base::Sys.info())
[17:28:39.097]                   }
[17:28:39.097]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.097]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:39.097]                     cond$call), session = sessionInformation(), 
[17:28:39.097]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:39.097]                   signalCondition(cond)
[17:28:39.097]                 }
[17:28:39.097]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:39.097]                 "immediateCondition"))) {
[17:28:39.097]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:39.097]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.097]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:39.097]                   if (TRUE && !signal) {
[17:28:39.097]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.097]                     {
[17:28:39.097]                       inherits <- base::inherits
[17:28:39.097]                       invokeRestart <- base::invokeRestart
[17:28:39.097]                       is.null <- base::is.null
[17:28:39.097]                       muffled <- FALSE
[17:28:39.097]                       if (inherits(cond, "message")) {
[17:28:39.097]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.097]                         if (muffled) 
[17:28:39.097]                           invokeRestart("muffleMessage")
[17:28:39.097]                       }
[17:28:39.097]                       else if (inherits(cond, "warning")) {
[17:28:39.097]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.097]                         if (muffled) 
[17:28:39.097]                           invokeRestart("muffleWarning")
[17:28:39.097]                       }
[17:28:39.097]                       else if (inherits(cond, "condition")) {
[17:28:39.097]                         if (!is.null(pattern)) {
[17:28:39.097]                           computeRestarts <- base::computeRestarts
[17:28:39.097]                           grepl <- base::grepl
[17:28:39.097]                           restarts <- computeRestarts(cond)
[17:28:39.097]                           for (restart in restarts) {
[17:28:39.097]                             name <- restart$name
[17:28:39.097]                             if (is.null(name)) 
[17:28:39.097]                               next
[17:28:39.097]                             if (!grepl(pattern, name)) 
[17:28:39.097]                               next
[17:28:39.097]                             invokeRestart(restart)
[17:28:39.097]                             muffled <- TRUE
[17:28:39.097]                             break
[17:28:39.097]                           }
[17:28:39.097]                         }
[17:28:39.097]                       }
[17:28:39.097]                       invisible(muffled)
[17:28:39.097]                     }
[17:28:39.097]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.097]                   }
[17:28:39.097]                 }
[17:28:39.097]                 else {
[17:28:39.097]                   if (TRUE) {
[17:28:39.097]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.097]                     {
[17:28:39.097]                       inherits <- base::inherits
[17:28:39.097]                       invokeRestart <- base::invokeRestart
[17:28:39.097]                       is.null <- base::is.null
[17:28:39.097]                       muffled <- FALSE
[17:28:39.097]                       if (inherits(cond, "message")) {
[17:28:39.097]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.097]                         if (muffled) 
[17:28:39.097]                           invokeRestart("muffleMessage")
[17:28:39.097]                       }
[17:28:39.097]                       else if (inherits(cond, "warning")) {
[17:28:39.097]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.097]                         if (muffled) 
[17:28:39.097]                           invokeRestart("muffleWarning")
[17:28:39.097]                       }
[17:28:39.097]                       else if (inherits(cond, "condition")) {
[17:28:39.097]                         if (!is.null(pattern)) {
[17:28:39.097]                           computeRestarts <- base::computeRestarts
[17:28:39.097]                           grepl <- base::grepl
[17:28:39.097]                           restarts <- computeRestarts(cond)
[17:28:39.097]                           for (restart in restarts) {
[17:28:39.097]                             name <- restart$name
[17:28:39.097]                             if (is.null(name)) 
[17:28:39.097]                               next
[17:28:39.097]                             if (!grepl(pattern, name)) 
[17:28:39.097]                               next
[17:28:39.097]                             invokeRestart(restart)
[17:28:39.097]                             muffled <- TRUE
[17:28:39.097]                             break
[17:28:39.097]                           }
[17:28:39.097]                         }
[17:28:39.097]                       }
[17:28:39.097]                       invisible(muffled)
[17:28:39.097]                     }
[17:28:39.097]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.097]                   }
[17:28:39.097]                 }
[17:28:39.097]             }
[17:28:39.097]         }))
[17:28:39.097]     }, error = function(ex) {
[17:28:39.097]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:39.097]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.097]                 ...future.rng), started = ...future.startTime, 
[17:28:39.097]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:39.097]             version = "1.8"), class = "FutureResult")
[17:28:39.097]     }, finally = {
[17:28:39.097]         if (!identical(...future.workdir, getwd())) 
[17:28:39.097]             setwd(...future.workdir)
[17:28:39.097]         {
[17:28:39.097]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:39.097]                 ...future.oldOptions$nwarnings <- NULL
[17:28:39.097]             }
[17:28:39.097]             base::options(...future.oldOptions)
[17:28:39.097]             if (.Platform$OS.type == "windows") {
[17:28:39.097]                 old_names <- names(...future.oldEnvVars)
[17:28:39.097]                 envs <- base::Sys.getenv()
[17:28:39.097]                 names <- names(envs)
[17:28:39.097]                 common <- intersect(names, old_names)
[17:28:39.097]                 added <- setdiff(names, old_names)
[17:28:39.097]                 removed <- setdiff(old_names, names)
[17:28:39.097]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:39.097]                   envs[common]]
[17:28:39.097]                 NAMES <- toupper(changed)
[17:28:39.097]                 args <- list()
[17:28:39.097]                 for (kk in seq_along(NAMES)) {
[17:28:39.097]                   name <- changed[[kk]]
[17:28:39.097]                   NAME <- NAMES[[kk]]
[17:28:39.097]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.097]                     next
[17:28:39.097]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.097]                 }
[17:28:39.097]                 NAMES <- toupper(added)
[17:28:39.097]                 for (kk in seq_along(NAMES)) {
[17:28:39.097]                   name <- added[[kk]]
[17:28:39.097]                   NAME <- NAMES[[kk]]
[17:28:39.097]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.097]                     next
[17:28:39.097]                   args[[name]] <- ""
[17:28:39.097]                 }
[17:28:39.097]                 NAMES <- toupper(removed)
[17:28:39.097]                 for (kk in seq_along(NAMES)) {
[17:28:39.097]                   name <- removed[[kk]]
[17:28:39.097]                   NAME <- NAMES[[kk]]
[17:28:39.097]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.097]                     next
[17:28:39.097]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.097]                 }
[17:28:39.097]                 if (length(args) > 0) 
[17:28:39.097]                   base::do.call(base::Sys.setenv, args = args)
[17:28:39.097]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:39.097]             }
[17:28:39.097]             else {
[17:28:39.097]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:39.097]             }
[17:28:39.097]             {
[17:28:39.097]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:39.097]                   0L) {
[17:28:39.097]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:39.097]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:39.097]                   base::options(opts)
[17:28:39.097]                 }
[17:28:39.097]                 {
[17:28:39.097]                   {
[17:28:39.097]                     NULL
[17:28:39.097]                     RNGkind("Mersenne-Twister")
[17:28:39.097]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:39.097]                       inherits = FALSE)
[17:28:39.097]                   }
[17:28:39.097]                   options(future.plan = NULL)
[17:28:39.097]                   if (is.na(NA_character_)) 
[17:28:39.097]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.097]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:39.097]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:39.097]                     .init = FALSE)
[17:28:39.097]                 }
[17:28:39.097]             }
[17:28:39.097]         }
[17:28:39.097]     })
[17:28:39.097]     if (TRUE) {
[17:28:39.097]         base::sink(type = "output", split = FALSE)
[17:28:39.097]         if (TRUE) {
[17:28:39.097]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:39.097]         }
[17:28:39.097]         else {
[17:28:39.097]             ...future.result["stdout"] <- base::list(NULL)
[17:28:39.097]         }
[17:28:39.097]         base::close(...future.stdout)
[17:28:39.097]         ...future.stdout <- NULL
[17:28:39.097]     }
[17:28:39.097]     ...future.result$conditions <- ...future.conditions
[17:28:39.097]     ...future.result$finished <- base::Sys.time()
[17:28:39.097]     ...future.result
[17:28:39.097] }
[17:28:39.106] assign_globals() ...
[17:28:39.106] List of 2
[17:28:39.106]  $ nested   :List of 2
[17:28:39.106]   ..$ a:function (..., envir = parent.frame())  
[17:28:39.106]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[17:28:39.106]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[17:28:39.106]   ..$ b:function (..., envir = parent.frame())  
[17:28:39.106]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[17:28:39.106]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[17:28:39.106]   ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[17:28:39.106]  $ strategy2: chr "sequential"
[17:28:39.106]  - attr(*, "where")=List of 2
[17:28:39.106]   ..$ nested   :<environment: R_EmptyEnv> 
[17:28:39.106]   ..$ strategy2:<environment: R_EmptyEnv> 
[17:28:39.106]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:39.106]  - attr(*, "resolved")= logi FALSE
[17:28:39.106]  - attr(*, "total_size")= int 3359
[17:28:39.106]  - attr(*, "already-done")= logi TRUE
[17:28:39.127] - copied 'nested' to environment
[17:28:39.127] - copied 'strategy2' to environment
[17:28:39.128] assign_globals() ... done
[17:28:39.129] plan(): Setting new future strategy stack:
[17:28:39.129] List of future strategies:
[17:28:39.129] 1. sequential:
[17:28:39.129]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.129]    - tweaked: FALSE
[17:28:39.129]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.131] plan(): nbrOfWorkers() = 1
[17:28:39.227] plan(): Setting new future strategy stack:
[17:28:39.228] List of future strategies:
[17:28:39.228] 1. sequential:
[17:28:39.228]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.228]    - tweaked: FALSE
[17:28:39.228]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.228] 2. sequential:
[17:28:39.228]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.228]    - tweaked: FALSE
[17:28:39.228]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.229] plan(): nbrOfWorkers() = 1
[17:28:39.230] SequentialFuture started (and completed)
[17:28:39.230] signalConditions() ...
[17:28:39.230]  - include = 'immediateCondition'
[17:28:39.231]  - exclude = 
[17:28:39.231]  - resignal = FALSE
[17:28:39.231]  - Number of conditions: 54
[17:28:39.232] signalConditions() ... done
[17:28:39.232] - Launch lazy future ... done
[17:28:39.232] run() for 'SequentialFuture' ... done
[17:28:39.233] signalConditions() ...
[17:28:39.233]  - include = 'immediateCondition'
[17:28:39.233]  - exclude = 
[17:28:39.234]  - resignal = FALSE
[17:28:39.234]  - Number of conditions: 54
[17:28:39.234] signalConditions() ... done
[17:28:39.235] Future state: 'finished'
[17:28:39.235] signalConditions() ...
[17:28:39.235]  - include = 'condition'
[17:28:39.236]  - exclude = 'immediateCondition'
[17:28:39.236]  - resignal = TRUE
[17:28:39.236]  - Number of conditions: 54
[17:28:39.237]  - Condition #1: 'simpleMessage', 'message', 'condition'
[17:28:39.134] getGlobalsAndPackages() ...
[17:28:39.237]  - Condition #2: 'simpleMessage', 'message', 'condition'
[17:28:39.134] Searching for globals...
[17:28:39.237]  - Condition #3: 'simpleMessage', 'message', 'condition'
[17:28:39.179] - globals found: [14] '{', '<-', '::', '[', 'nested_a', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'list', 'a', 'plan_a'
[17:28:39.238]  - Condition #4: 'simpleMessage', 'message', 'condition'
[17:28:39.180] Searching for globals ... DONE
[17:28:39.238]  - Condition #5: 'simpleMessage', 'message', 'condition'
[17:28:39.180] Resolving globals: FALSE
[17:28:39.239]  - Condition #6: 'simpleMessage', 'message', 'condition'
[17:28:39.182] The total size of the 3 globals is 3.58 KiB (3661 bytes)
[17:28:39.239]  - Condition #7: 'simpleMessage', 'message', 'condition'
[17:28:39.183] The total size of the 3 globals exported for future expression ('{; b <- 2L; plan_b <- future::plan("list"); nested_b <- nested_a[-1]; stopifnot(length(nested_b) == 0L, length(plan_b) == 1L, inherits(plan_b[[1]],; "future"), inherits(future::plan("next"), "sequential")); list(a = a, nested_a = nested_a, plan_a = plan_a, b = b,; nested_b = nested_b, plan_b = plan_b); }') is 3.58 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'nested_a' (1.77 KiB of class 'list'), 'plan_a' (1.77 KiB of class 'list') and 'a' (35 bytes of class 'numeric')
[17:28:39.240]  - Condition #8: 'simpleMessage', 'message', 'condition'
[17:28:39.183] - globals: [3] 'nested_a', 'a', 'plan_a'
[17:28:39.240]  - Condition #9: 'simpleMessage', 'message', 'condition'
[17:28:39.184] 
[17:28:39.240]  - Condition #10: 'simpleMessage', 'message', 'condition'
[17:28:39.184] getGlobalsAndPackages() ... DONE
[17:28:39.241]  - Condition #11: 'simpleMessage', 'message', 'condition'
[17:28:39.185] run() for 'Future' ...
[17:28:39.241]  - Condition #12: 'simpleMessage', 'message', 'condition'
[17:28:39.185] - state: 'created'
[17:28:39.242]  - Condition #13: 'simpleMessage', 'message', 'condition'
[17:28:39.185] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:39.242]  - Condition #14: 'simpleMessage', 'message', 'condition'
[17:28:39.186] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:39.242]  - Condition #15: 'simpleMessage', 'message', 'condition'
[17:28:39.187] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:39.243]  - Condition #16: 'simpleMessage', 'message', 'condition'
[17:28:39.187]   - Field: 'label'
[17:28:39.243]  - Condition #17: 'simpleMessage', 'message', 'condition'
[17:28:39.187]   - Field: 'local'
[17:28:39.244]  - Condition #18: 'simpleMessage', 'message', 'condition'
[17:28:39.188]   - Field: 'owner'
[17:28:39.244]  - Condition #19: 'simpleMessage', 'message', 'condition'
[17:28:39.188]   - Field: 'envir'
[17:28:39.244]  - Condition #20: 'simpleMessage', 'message', 'condition'
[17:28:39.188]   - Field: 'packages'
[17:28:39.245]  - Condition #21: 'simpleMessage', 'message', 'condition'
[17:28:39.189]   - Field: 'gc'
[17:28:39.245]  - Condition #22: 'simpleMessage', 'message', 'condition'
[17:28:39.189]   - Field: 'conditions'
[17:28:39.246]  - Condition #23: 'simpleMessage', 'message', 'condition'
[17:28:39.189]   - Field: 'expr'
[17:28:39.246]  - Condition #24: 'simpleMessage', 'message', 'condition'
[17:28:39.190]   - Field: 'uuid'
[17:28:39.246]  - Condition #25: 'simpleMessage', 'message', 'condition'
[17:28:39.190]   - Field: 'seed'
[17:28:39.247]  - Condition #26: 'simpleMessage', 'message', 'condition'
[17:28:39.191]   - Field: 'version'
[17:28:39.247]  - Condition #27: 'simpleMessage', 'message', 'condition'
[17:28:39.191]   - Field: 'result'
[17:28:39.248]  - Condition #28: 'simpleMessage', 'message', 'condition'
[17:28:39.191]   - Field: 'asynchronous'
[17:28:39.248]  - Condition #29: 'simpleMessage', 'message', 'condition'
[17:28:39.192]   - Field: 'calls'
[17:28:39.248]  - Condition #30: 'simpleMessage', 'message', 'condition'
[17:28:39.192]   - Field: 'globals'
[17:28:39.249]  - Condition #31: 'simpleMessage', 'message', 'condition'
[17:28:39.192]   - Field: 'stdout'
[17:28:39.249]  - Condition #32: 'simpleMessage', 'message', 'condition'
[17:28:39.193]   - Field: 'earlySignal'
[17:28:39.250]  - Condition #33: 'simpleMessage', 'message', 'condition'
[17:28:39.193]   - Field: 'lazy'
[17:28:39.250]  - Condition #34: 'simpleMessage', 'message', 'condition'
[17:28:39.193]   - Field: 'state'
[17:28:39.250]  - Condition #35: 'simpleMessage', 'message', 'condition'
[17:28:39.194] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:39.251]  - Condition #36: 'simpleMessage', 'message', 'condition'
[17:28:39.194] - Launch lazy future ...
[17:28:39.251]  - Condition #37: 'simpleMessage', 'message', 'condition'
[17:28:39.195] Packages needed by the future expression (n = 0): <none>
[17:28:39.252]  - Condition #38: 'simpleMessage', 'message', 'condition'
[17:28:39.195] Packages needed by future strategies (n = 0): <none>
[17:28:39.252]  - Condition #39: 'simpleMessage', 'message', 'condition'
[17:28:39.196] {
[17:28:39.196]     {
[17:28:39.196]         {
[17:28:39.196]             ...future.startTime <- base::Sys.time()
[17:28:39.196]             {
[17:28:39.196]                 {
[17:28:39.196]                   {
[17:28:39.196]                     base::local({
[17:28:39.196]                       has_future <- base::requireNamespace("future", 
[17:28:39.196]                         quietly = TRUE)
[17:28:39.196]                       if (has_future) {
[17:28:39.196]                         ns <- base::getNamespace("future")
[17:28:39.196]                         version <- ns[[".package"]][["version"]]
[17:28:39.196]                         if (is.null(version)) 
[17:28:39.196]                           version <- utils::packageVersion("future")
[17:28:39.196]                       }
[17:28:39.196]                       else {
[17:28:39.196]                         version <- NULL
[17:28:39.196]                       }
[17:28:39.196]                       if (!has_future || version < "1.8.0") {
[17:28:39.196]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:39.196]                           "", base::R.version$version.string), 
[17:28:39.196]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:39.196]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:39.196]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:39.196]                             "release", "version")], collapse = " "), 
[17:28:39.196]                           hostname = base::Sys.info()[["nodename"]])
[17:28:39.196]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:39.196]                           info)
[17:28:39.196]                         info <- base::paste(info, collapse = "; ")
[17:28:39.196]                         if (!has_future) {
[17:28:39.196]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:39.196]                             info)
[17:28:39.196]                         }
[17:28:39.196]                         else {
[17:28:39.196]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:39.196]                             info, version)
[17:28:39.196]                         }
[17:28:39.196]                         base::stop(msg)
[17:28:39.196]                       }
[17:28:39.196]                     })
[17:28:39.196]                   }
[17:28:39.196]                   ...future.strategy.old <- future::plan("list")
[17:28:39.196]                   options(future.plan = NULL)
[17:28:39.196]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.196]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:39.196]                 }
[17:28:39.196]                 ...future.workdir <- getwd()
[17:28:39.196]             }
[17:28:39.196]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:39.196]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:39.196]         }
[17:28:39.196]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:39.196]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:39.196]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:39.196]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:39.196]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:39.196]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:39.196]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:39.196]             base::names(...future.oldOptions))
[17:28:39.196]     }
[17:28:39.196]     if (FALSE) {
[17:28:39.196]     }
[17:28:39.196]     else {
[17:28:39.196]         if (TRUE) {
[17:28:39.196]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:39.196]                 open = "w")
[17:28:39.196]         }
[17:28:39.196]         else {
[17:28:39.196]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:39.196]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:39.196]         }
[17:28:39.196]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:39.196]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:39.196]             base::sink(type = "output", split = FALSE)
[17:28:39.196]             base::close(...future.stdout)
[17:28:39.196]         }, add = TRUE)
[17:28:39.196]     }
[17:28:39.196]     ...future.frame <- base::sys.nframe()
[17:28:39.196]     ...future.conditions <- base::list()
[17:28:39.196]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:39.196]     if (FALSE) {
[17:28:39.196]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:39.196]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:39.196]     }
[17:28:39.196]     ...future.result <- base::tryCatch({
[17:28:39.196]         base::withCallingHandlers({
[17:28:39.196]             ...future.value <- base::withVisible(base::local({
[17:28:39.196]                 b <- 2L
[17:28:39.196]                 plan_b <- future::plan("list")
[17:28:39.196]                 nested_b <- nested_a[-1]
[17:28:39.196]                 stopifnot(length(nested_b) == 0L, length(plan_b) == 
[17:28:39.196]                   1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[17:28:39.196]                   "sequential"))
[17:28:39.196]                 list(a = a, nested_a = nested_a, plan_a = plan_a, 
[17:28:39.196]                   b = b, nested_b = nested_b, plan_b = plan_b)
[17:28:39.196]             }))
[17:28:39.196]             future::FutureResult(value = ...future.value$value, 
[17:28:39.196]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.196]                   ...future.rng), globalenv = if (FALSE) 
[17:28:39.196]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:39.196]                     ...future.globalenv.names))
[17:28:39.196]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:39.196]         }, condition = base::local({
[17:28:39.196]             c <- base::c
[17:28:39.196]             inherits <- base::inherits
[17:28:39.196]             invokeRestart <- base::invokeRestart
[17:28:39.196]             length <- base::length
[17:28:39.196]             list <- base::list
[17:28:39.196]             seq.int <- base::seq.int
[17:28:39.196]             signalCondition <- base::signalCondition
[17:28:39.196]             sys.calls <- base::sys.calls
[17:28:39.196]             `[[` <- base::`[[`
[17:28:39.196]             `+` <- base::`+`
[17:28:39.196]             `<<-` <- base::`<<-`
[17:28:39.196]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:39.196]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:39.196]                   3L)]
[17:28:39.196]             }
[17:28:39.196]             function(cond) {
[17:28:39.196]                 is_error <- inherits(cond, "error")
[17:28:39.196]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:39.196]                   NULL)
[17:28:39.196]                 if (is_error) {
[17:28:39.196]                   sessionInformation <- function() {
[17:28:39.196]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:39.196]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:39.196]                       search = base::search(), system = base::Sys.info())
[17:28:39.196]                   }
[17:28:39.196]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.196]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:39.196]                     cond$call), session = sessionInformation(), 
[17:28:39.196]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:39.196]                   signalCondition(cond)
[17:28:39.196]                 }
[17:28:39.196]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:39.196]                 "immediateCondition"))) {
[17:28:39.196]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:39.196]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.196]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:39.196]                   if (TRUE && !signal) {
[17:28:39.196]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.196]                     {
[17:28:39.196]                       inherits <- base::inherits
[17:28:39.196]                       invokeRestart <- base::invokeRestart
[17:28:39.196]                       is.null <- base::is.null
[17:28:39.196]                       muffled <- FALSE
[17:28:39.196]                       if (inherits(cond, "message")) {
[17:28:39.196]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.196]                         if (muffled) 
[17:28:39.196]                           invokeRestart("muffleMessage")
[17:28:39.196]                       }
[17:28:39.196]                       else if (inherits(cond, "warning")) {
[17:28:39.196]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.196]                         if (muffled) 
[17:28:39.196]                           invokeRestart("muffleWarning")
[17:28:39.196]                       }
[17:28:39.196]                       else if (inherits(cond, "condition")) {
[17:28:39.196]                         if (!is.null(pattern)) {
[17:28:39.196]                           computeRestarts <- base::computeRestarts
[17:28:39.196]                           grepl <- base::grepl
[17:28:39.196]                           restarts <- computeRestarts(cond)
[17:28:39.196]                           for (restart in restarts) {
[17:28:39.196]                             name <- restart$name
[17:28:39.196]                             if (is.null(name)) 
[17:28:39.196]                               next
[17:28:39.196]                             if (!grepl(pattern, name)) 
[17:28:39.196]                               next
[17:28:39.196]                             invokeRestart(restart)
[17:28:39.196]                             muffled <- TRUE
[17:28:39.196]                             break
[17:28:39.196]                           }
[17:28:39.196]                         }
[17:28:39.196]                       }
[17:28:39.196]                       invisible(muffled)
[17:28:39.196]                     }
[17:28:39.196]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.196]                   }
[17:28:39.196]                 }
[17:28:39.196]                 else {
[17:28:39.196]                   if (TRUE) {
[17:28:39.196]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.196]                     {
[17:28:39.196]                       inherits <- base::inherits
[17:28:39.196]                       invokeRestart <- base::invokeRestart
[17:28:39.196]                       is.null <- base::is.null
[17:28:39.196]                       muffled <- FALSE
[17:28:39.196]                       if (inherits(cond, "message")) {
[17:28:39.196]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.196]                         if (muffled) 
[17:28:39.196]                           invokeRestart("muffleMessage")
[17:28:39.196]                       }
[17:28:39.196]                       else if (inherits(cond, "warning")) {
[17:28:39.196]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.196]                         if (muffled) 
[17:28:39.196]                           invokeRestart("muffleWarning")
[17:28:39.196]                       }
[17:28:39.196]                       else if (inherits(cond, "condition")) {
[17:28:39.196]                         if (!is.null(pattern)) {
[17:28:39.196]                           computeRestarts <- base::computeRestarts
[17:28:39.196]                           grepl <- base::grepl
[17:28:39.196]                           restarts <- computeRestarts(cond)
[17:28:39.196]                           for (restart in restarts) {
[17:28:39.196]                             name <- restart$name
[17:28:39.196]                             if (is.null(name)) 
[17:28:39.196]                               next
[17:28:39.196]                             if (!grepl(pattern, name)) 
[17:28:39.196]                               next
[17:28:39.196]                             invokeRestart(restart)
[17:28:39.196]                             muffled <- TRUE
[17:28:39.196]                             break
[17:28:39.196]                           }
[17:28:39.196]                         }
[17:28:39.196]                       }
[17:28:39.196]                       invisible(muffled)
[17:28:39.196]                     }
[17:28:39.196]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.196]                   }
[17:28:39.196]                 }
[17:28:39.196]             }
[17:28:39.196]         }))
[17:28:39.196]     }, error = function(ex) {
[17:28:39.196]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:39.196]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.196]                 ...future.rng), started = ...future.startTime, 
[17:28:39.196]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:39.196]             version = "1.8"), class = "FutureResult")
[17:28:39.196]     }, finally = {
[17:28:39.196]         if (!identical(...future.workdir, getwd())) 
[17:28:39.196]             setwd(...future.workdir)
[17:28:39.196]         {
[17:28:39.196]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:39.196]                 ...future.oldOptions$nwarnings <- NULL
[17:28:39.196]             }
[17:28:39.196]             base::options(...future.oldOptions)
[17:28:39.196]             if (.Platform$OS.type == "windows") {
[17:28:39.196]                 old_names <- names(...future.oldEnvVars)
[17:28:39.196]                 envs <- base::Sys.getenv()
[17:28:39.196]                 names <- names(envs)
[17:28:39.196]                 common <- intersect(names, old_names)
[17:28:39.196]                 added <- setdiff(names, old_names)
[17:28:39.196]                 removed <- setdiff(old_names, names)
[17:28:39.196]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:39.196]                   envs[common]]
[17:28:39.196]                 NAMES <- toupper(changed)
[17:28:39.196]                 args <- list()
[17:28:39.196]                 for (kk in seq_along(NAMES)) {
[17:28:39.196]                   name <- changed[[kk]]
[17:28:39.196]                   NAME <- NAMES[[kk]]
[17:28:39.196]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.196]                     next
[17:28:39.196]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.196]                 }
[17:28:39.196]                 NAMES <- toupper(added)
[17:28:39.196]                 for (kk in seq_along(NAMES)) {
[17:28:39.196]                   name <- added[[kk]]
[17:28:39.196]                   NAME <- NAMES[[kk]]
[17:28:39.196]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.196]                     next
[17:28:39.196]                   args[[name]] <- ""
[17:28:39.196]                 }
[17:28:39.196]                 NAMES <- toupper(removed)
[17:28:39.196]                 for (kk in seq_along(NAMES)) {
[17:28:39.196]                   name <- removed[[kk]]
[17:28:39.196]                   NAME <- NAMES[[kk]]
[17:28:39.196]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.196]                     next
[17:28:39.196]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.196]                 }
[17:28:39.196]                 if (length(args) > 0) 
[17:28:39.196]                   base::do.call(base::Sys.setenv, args = args)
[17:28:39.196]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:39.196]             }
[17:28:39.196]             else {
[17:28:39.196]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:39.196]             }
[17:28:39.196]             {
[17:28:39.196]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:39.196]                   0L) {
[17:28:39.196]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:39.196]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:39.196]                   base::options(opts)
[17:28:39.196]                 }
[17:28:39.196]                 {
[17:28:39.196]                   {
[17:28:39.196]                     NULL
[17:28:39.196]                     RNGkind("Mersenne-Twister")
[17:28:39.196]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:39.196]                       inherits = FALSE)
[17:28:39.196]                   }
[17:28:39.196]                   options(future.plan = NULL)
[17:28:39.196]                   if (is.na(NA_character_)) 
[17:28:39.196]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.196]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:39.196]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:39.196]                     .init = FALSE)
[17:28:39.196]                 }
[17:28:39.196]             }
[17:28:39.196]         }
[17:28:39.196]     })
[17:28:39.196]     if (TRUE) {
[17:28:39.196]         base::sink(type = "output", split = FALSE)
[17:28:39.196]         if (TRUE) {
[17:28:39.196]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:39.196]         }
[17:28:39.196]         else {
[17:28:39.196]             ...future.result["stdout"] <- base::list(NULL)
[17:28:39.196]         }
[17:28:39.196]         base::close(...future.stdout)
[17:28:39.196]         ...future.stdout <- NULL
[17:28:39.196]     }
[17:28:39.196]     ...future.result$conditions <- ...future.conditions
[17:28:39.196]     ...future.result$finished <- base::Sys.time()
[17:28:39.196]     ...future.result
[17:28:39.196] }
[17:28:39.252]  - Condition #40: 'simpleMessage', 'message', 'condition'
[17:28:39.202] assign_globals() ...
[17:28:39.253]  - Condition #41: 'simpleMessage', 'message', 'condition'
[17:28:39.203] List of 3
[17:28:39.203]  $ nested_a:List of 1
[17:28:39.203]   ..$ b:function (..., envir = parent.frame())  
[17:28:39.203]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[17:28:39.203]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[17:28:39.203]  $ a       : int 1
[17:28:39.203]  $ plan_a  :List of 1
[17:28:39.203]   ..$ b:function (..., envir = parent.frame())  
[17:28:39.203]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[17:28:39.203]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[17:28:39.203]  - attr(*, "where")=List of 3
[17:28:39.203]   ..$ nested_a:<environment: R_EmptyEnv> 
[17:28:39.203]   ..$ a       :<environment: R_EmptyEnv> 
[17:28:39.203]   ..$ plan_a  :<environment: R_EmptyEnv> 
[17:28:39.203]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:39.203]  - attr(*, "resolved")= logi FALSE
[17:28:39.203]  - attr(*, "total_size")= int 3661
[17:28:39.203]  - attr(*, "already-done")= logi TRUE
[17:28:39.253]  - Condition #42: 'simpleMessage', 'message', 'condition'
[17:28:39.216] - copied 'nested_a' to environment
[17:28:39.253]  - Condition #43: 'simpleMessage', 'message', 'condition'
[17:28:39.216] - copied 'a' to environment
[17:28:39.253]  - Condition #44: 'simpleMessage', 'message', 'condition'
[17:28:39.216] - copied 'plan_a' to environment
[17:28:39.254]  - Condition #45: 'simpleMessage', 'message', 'condition'
[17:28:39.217] assign_globals() ... done
[17:28:39.254]  - Condition #46: 'simpleMessage', 'message', 'condition'
[17:28:39.217] plan(): Setting new future strategy stack:
[17:28:39.254]  - Condition #47: 'simpleMessage', 'message', 'condition'
[17:28:39.218] List of future strategies:
[17:28:39.218] 1. sequential:
[17:28:39.218]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.218]    - tweaked: FALSE
[17:28:39.218]    - call: NULL
[17:28:39.254]  - Condition #48: 'simpleMessage', 'message', 'condition'
[17:28:39.219] plan(): nbrOfWorkers() = 1
[17:28:39.254]  - Condition #49: 'simpleMessage', 'message', 'condition'
[17:28:39.222] plan(): Setting new future strategy stack:
[17:28:39.255]  - Condition #50: 'simpleMessage', 'message', 'condition'
[17:28:39.222] List of future strategies:
[17:28:39.222] 1. sequential:
[17:28:39.222]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.222]    - tweaked: FALSE
[17:28:39.222]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.257]  - Condition #51: 'simpleMessage', 'message', 'condition'
[17:28:39.223] plan(): nbrOfWorkers() = 1
[17:28:39.257]  - Condition #52: 'simpleMessage', 'message', 'condition'
[17:28:39.224] SequentialFuture started (and completed)
[17:28:39.257]  - Condition #53: 'simpleMessage', 'message', 'condition'
[17:28:39.225] - Launch lazy future ... done
[17:28:39.257]  - Condition #54: 'simpleMessage', 'message', 'condition'
[17:28:39.225] run() for 'SequentialFuture' ... done
[17:28:39.258] signalConditions() ... done
List of 6
 $ a       : int 1
 $ nested_a:List of 1
  ..$ b:function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ plan_a  :List of 1
  ..$ b:function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ b       : int 2
 $ nested_b: Named list()
 $ plan_b  :List of 1
  ..$ :function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[17:28:39.264] getGlobalsAndPackages() ...
[17:28:39.265] Searching for globals...
[17:28:39.266] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[17:28:39.266] Searching for globals ... DONE
[17:28:39.267] Resolving globals: FALSE
[17:28:39.267] The total size of the 1 globals is 356 bytes (356 bytes)
[17:28:39.268] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 356 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (356 bytes of class 'list')
[17:28:39.268] - globals: [1] 'data'
[17:28:39.268] - packages: [1] 'future'
[17:28:39.269] getGlobalsAndPackages() ... DONE
[17:28:39.269] run() for 'Future' ...
[17:28:39.269] - state: 'created'
[17:28:39.269] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:39.270] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:39.270] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:39.270]   - Field: 'label'
[17:28:39.270]   - Field: 'local'
[17:28:39.271]   - Field: 'owner'
[17:28:39.271]   - Field: 'envir'
[17:28:39.271]   - Field: 'packages'
[17:28:39.271]   - Field: 'gc'
[17:28:39.271]   - Field: 'conditions'
[17:28:39.271]   - Field: 'expr'
[17:28:39.272]   - Field: 'uuid'
[17:28:39.272]   - Field: 'seed'
[17:28:39.272]   - Field: 'version'
[17:28:39.272]   - Field: 'result'
[17:28:39.272]   - Field: 'asynchronous'
[17:28:39.273]   - Field: 'calls'
[17:28:39.273]   - Field: 'globals'
[17:28:39.273]   - Field: 'stdout'
[17:28:39.273]   - Field: 'earlySignal'
[17:28:39.273]   - Field: 'lazy'
[17:28:39.273]   - Field: 'state'
[17:28:39.274] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:39.274] - Launch lazy future ...
[17:28:39.274] Packages needed by the future expression (n = 1): 'future'
[17:28:39.274] Packages needed by future strategies (n = 1): 'future'
[17:28:39.275] {
[17:28:39.275]     {
[17:28:39.275]         {
[17:28:39.275]             ...future.startTime <- base::Sys.time()
[17:28:39.275]             {
[17:28:39.275]                 {
[17:28:39.275]                   {
[17:28:39.275]                     {
[17:28:39.275]                       base::local({
[17:28:39.275]                         has_future <- base::requireNamespace("future", 
[17:28:39.275]                           quietly = TRUE)
[17:28:39.275]                         if (has_future) {
[17:28:39.275]                           ns <- base::getNamespace("future")
[17:28:39.275]                           version <- ns[[".package"]][["version"]]
[17:28:39.275]                           if (is.null(version)) 
[17:28:39.275]                             version <- utils::packageVersion("future")
[17:28:39.275]                         }
[17:28:39.275]                         else {
[17:28:39.275]                           version <- NULL
[17:28:39.275]                         }
[17:28:39.275]                         if (!has_future || version < "1.8.0") {
[17:28:39.275]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:39.275]                             "", base::R.version$version.string), 
[17:28:39.275]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:39.275]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:39.275]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:39.275]                               "release", "version")], collapse = " "), 
[17:28:39.275]                             hostname = base::Sys.info()[["nodename"]])
[17:28:39.275]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:39.275]                             info)
[17:28:39.275]                           info <- base::paste(info, collapse = "; ")
[17:28:39.275]                           if (!has_future) {
[17:28:39.275]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:39.275]                               info)
[17:28:39.275]                           }
[17:28:39.275]                           else {
[17:28:39.275]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:39.275]                               info, version)
[17:28:39.275]                           }
[17:28:39.275]                           base::stop(msg)
[17:28:39.275]                         }
[17:28:39.275]                       })
[17:28:39.275]                     }
[17:28:39.275]                     base::local({
[17:28:39.275]                       for (pkg in "future") {
[17:28:39.275]                         base::loadNamespace(pkg)
[17:28:39.275]                         base::library(pkg, character.only = TRUE)
[17:28:39.275]                       }
[17:28:39.275]                     })
[17:28:39.275]                   }
[17:28:39.275]                   ...future.strategy.old <- future::plan("list")
[17:28:39.275]                   options(future.plan = NULL)
[17:28:39.275]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.275]                   future::plan(list(b = function (..., envir = parent.frame()) 
[17:28:39.275]                   {
[17:28:39.275]                     future <- SequentialFuture(..., envir = envir)
[17:28:39.275]                     if (!future$lazy) 
[17:28:39.275]                       future <- run(future)
[17:28:39.275]                     invisible(future)
[17:28:39.275]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:39.275]                 }
[17:28:39.275]                 ...future.workdir <- getwd()
[17:28:39.275]             }
[17:28:39.275]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:39.275]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:39.275]         }
[17:28:39.275]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:39.275]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:39.275]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:39.275]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:39.275]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:39.275]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:39.275]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:39.275]             base::names(...future.oldOptions))
[17:28:39.275]     }
[17:28:39.275]     if (FALSE) {
[17:28:39.275]     }
[17:28:39.275]     else {
[17:28:39.275]         if (TRUE) {
[17:28:39.275]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:39.275]                 open = "w")
[17:28:39.275]         }
[17:28:39.275]         else {
[17:28:39.275]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:39.275]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:39.275]         }
[17:28:39.275]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:39.275]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:39.275]             base::sink(type = "output", split = FALSE)
[17:28:39.275]             base::close(...future.stdout)
[17:28:39.275]         }, add = TRUE)
[17:28:39.275]     }
[17:28:39.275]     ...future.frame <- base::sys.nframe()
[17:28:39.275]     ...future.conditions <- base::list()
[17:28:39.275]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:39.275]     if (FALSE) {
[17:28:39.275]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:39.275]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:39.275]     }
[17:28:39.275]     ...future.result <- base::tryCatch({
[17:28:39.275]         base::withCallingHandlers({
[17:28:39.275]             ...future.value <- base::withVisible(base::local({
[17:28:39.275]                 value(future(subset(data, a == 2)))
[17:28:39.275]             }))
[17:28:39.275]             future::FutureResult(value = ...future.value$value, 
[17:28:39.275]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.275]                   ...future.rng), globalenv = if (FALSE) 
[17:28:39.275]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:39.275]                     ...future.globalenv.names))
[17:28:39.275]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:39.275]         }, condition = base::local({
[17:28:39.275]             c <- base::c
[17:28:39.275]             inherits <- base::inherits
[17:28:39.275]             invokeRestart <- base::invokeRestart
[17:28:39.275]             length <- base::length
[17:28:39.275]             list <- base::list
[17:28:39.275]             seq.int <- base::seq.int
[17:28:39.275]             signalCondition <- base::signalCondition
[17:28:39.275]             sys.calls <- base::sys.calls
[17:28:39.275]             `[[` <- base::`[[`
[17:28:39.275]             `+` <- base::`+`
[17:28:39.275]             `<<-` <- base::`<<-`
[17:28:39.275]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:39.275]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:39.275]                   3L)]
[17:28:39.275]             }
[17:28:39.275]             function(cond) {
[17:28:39.275]                 is_error <- inherits(cond, "error")
[17:28:39.275]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:39.275]                   NULL)
[17:28:39.275]                 if (is_error) {
[17:28:39.275]                   sessionInformation <- function() {
[17:28:39.275]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:39.275]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:39.275]                       search = base::search(), system = base::Sys.info())
[17:28:39.275]                   }
[17:28:39.275]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.275]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:39.275]                     cond$call), session = sessionInformation(), 
[17:28:39.275]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:39.275]                   signalCondition(cond)
[17:28:39.275]                 }
[17:28:39.275]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:39.275]                 "immediateCondition"))) {
[17:28:39.275]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:39.275]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.275]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:39.275]                   if (TRUE && !signal) {
[17:28:39.275]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.275]                     {
[17:28:39.275]                       inherits <- base::inherits
[17:28:39.275]                       invokeRestart <- base::invokeRestart
[17:28:39.275]                       is.null <- base::is.null
[17:28:39.275]                       muffled <- FALSE
[17:28:39.275]                       if (inherits(cond, "message")) {
[17:28:39.275]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.275]                         if (muffled) 
[17:28:39.275]                           invokeRestart("muffleMessage")
[17:28:39.275]                       }
[17:28:39.275]                       else if (inherits(cond, "warning")) {
[17:28:39.275]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.275]                         if (muffled) 
[17:28:39.275]                           invokeRestart("muffleWarning")
[17:28:39.275]                       }
[17:28:39.275]                       else if (inherits(cond, "condition")) {
[17:28:39.275]                         if (!is.null(pattern)) {
[17:28:39.275]                           computeRestarts <- base::computeRestarts
[17:28:39.275]                           grepl <- base::grepl
[17:28:39.275]                           restarts <- computeRestarts(cond)
[17:28:39.275]                           for (restart in restarts) {
[17:28:39.275]                             name <- restart$name
[17:28:39.275]                             if (is.null(name)) 
[17:28:39.275]                               next
[17:28:39.275]                             if (!grepl(pattern, name)) 
[17:28:39.275]                               next
[17:28:39.275]                             invokeRestart(restart)
[17:28:39.275]                             muffled <- TRUE
[17:28:39.275]                             break
[17:28:39.275]                           }
[17:28:39.275]                         }
[17:28:39.275]                       }
[17:28:39.275]                       invisible(muffled)
[17:28:39.275]                     }
[17:28:39.275]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.275]                   }
[17:28:39.275]                 }
[17:28:39.275]                 else {
[17:28:39.275]                   if (TRUE) {
[17:28:39.275]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.275]                     {
[17:28:39.275]                       inherits <- base::inherits
[17:28:39.275]                       invokeRestart <- base::invokeRestart
[17:28:39.275]                       is.null <- base::is.null
[17:28:39.275]                       muffled <- FALSE
[17:28:39.275]                       if (inherits(cond, "message")) {
[17:28:39.275]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.275]                         if (muffled) 
[17:28:39.275]                           invokeRestart("muffleMessage")
[17:28:39.275]                       }
[17:28:39.275]                       else if (inherits(cond, "warning")) {
[17:28:39.275]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.275]                         if (muffled) 
[17:28:39.275]                           invokeRestart("muffleWarning")
[17:28:39.275]                       }
[17:28:39.275]                       else if (inherits(cond, "condition")) {
[17:28:39.275]                         if (!is.null(pattern)) {
[17:28:39.275]                           computeRestarts <- base::computeRestarts
[17:28:39.275]                           grepl <- base::grepl
[17:28:39.275]                           restarts <- computeRestarts(cond)
[17:28:39.275]                           for (restart in restarts) {
[17:28:39.275]                             name <- restart$name
[17:28:39.275]                             if (is.null(name)) 
[17:28:39.275]                               next
[17:28:39.275]                             if (!grepl(pattern, name)) 
[17:28:39.275]                               next
[17:28:39.275]                             invokeRestart(restart)
[17:28:39.275]                             muffled <- TRUE
[17:28:39.275]                             break
[17:28:39.275]                           }
[17:28:39.275]                         }
[17:28:39.275]                       }
[17:28:39.275]                       invisible(muffled)
[17:28:39.275]                     }
[17:28:39.275]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.275]                   }
[17:28:39.275]                 }
[17:28:39.275]             }
[17:28:39.275]         }))
[17:28:39.275]     }, error = function(ex) {
[17:28:39.275]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:39.275]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.275]                 ...future.rng), started = ...future.startTime, 
[17:28:39.275]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:39.275]             version = "1.8"), class = "FutureResult")
[17:28:39.275]     }, finally = {
[17:28:39.275]         if (!identical(...future.workdir, getwd())) 
[17:28:39.275]             setwd(...future.workdir)
[17:28:39.275]         {
[17:28:39.275]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:39.275]                 ...future.oldOptions$nwarnings <- NULL
[17:28:39.275]             }
[17:28:39.275]             base::options(...future.oldOptions)
[17:28:39.275]             if (.Platform$OS.type == "windows") {
[17:28:39.275]                 old_names <- names(...future.oldEnvVars)
[17:28:39.275]                 envs <- base::Sys.getenv()
[17:28:39.275]                 names <- names(envs)
[17:28:39.275]                 common <- intersect(names, old_names)
[17:28:39.275]                 added <- setdiff(names, old_names)
[17:28:39.275]                 removed <- setdiff(old_names, names)
[17:28:39.275]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:39.275]                   envs[common]]
[17:28:39.275]                 NAMES <- toupper(changed)
[17:28:39.275]                 args <- list()
[17:28:39.275]                 for (kk in seq_along(NAMES)) {
[17:28:39.275]                   name <- changed[[kk]]
[17:28:39.275]                   NAME <- NAMES[[kk]]
[17:28:39.275]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.275]                     next
[17:28:39.275]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.275]                 }
[17:28:39.275]                 NAMES <- toupper(added)
[17:28:39.275]                 for (kk in seq_along(NAMES)) {
[17:28:39.275]                   name <- added[[kk]]
[17:28:39.275]                   NAME <- NAMES[[kk]]
[17:28:39.275]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.275]                     next
[17:28:39.275]                   args[[name]] <- ""
[17:28:39.275]                 }
[17:28:39.275]                 NAMES <- toupper(removed)
[17:28:39.275]                 for (kk in seq_along(NAMES)) {
[17:28:39.275]                   name <- removed[[kk]]
[17:28:39.275]                   NAME <- NAMES[[kk]]
[17:28:39.275]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.275]                     next
[17:28:39.275]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.275]                 }
[17:28:39.275]                 if (length(args) > 0) 
[17:28:39.275]                   base::do.call(base::Sys.setenv, args = args)
[17:28:39.275]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:39.275]             }
[17:28:39.275]             else {
[17:28:39.275]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:39.275]             }
[17:28:39.275]             {
[17:28:39.275]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:39.275]                   0L) {
[17:28:39.275]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:39.275]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:39.275]                   base::options(opts)
[17:28:39.275]                 }
[17:28:39.275]                 {
[17:28:39.275]                   {
[17:28:39.275]                     NULL
[17:28:39.275]                     RNGkind("Mersenne-Twister")
[17:28:39.275]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:39.275]                       inherits = FALSE)
[17:28:39.275]                   }
[17:28:39.275]                   options(future.plan = NULL)
[17:28:39.275]                   if (is.na(NA_character_)) 
[17:28:39.275]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.275]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:39.275]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:39.275]                     .init = FALSE)
[17:28:39.275]                 }
[17:28:39.275]             }
[17:28:39.275]         }
[17:28:39.275]     })
[17:28:39.275]     if (TRUE) {
[17:28:39.275]         base::sink(type = "output", split = FALSE)
[17:28:39.275]         if (TRUE) {
[17:28:39.275]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:39.275]         }
[17:28:39.275]         else {
[17:28:39.275]             ...future.result["stdout"] <- base::list(NULL)
[17:28:39.275]         }
[17:28:39.275]         base::close(...future.stdout)
[17:28:39.275]         ...future.stdout <- NULL
[17:28:39.275]     }
[17:28:39.275]     ...future.result$conditions <- ...future.conditions
[17:28:39.275]     ...future.result$finished <- base::Sys.time()
[17:28:39.275]     ...future.result
[17:28:39.275] }
[17:28:39.279] assign_globals() ...
[17:28:39.279] List of 1
[17:28:39.279]  $ data:'data.frame':	3 obs. of  2 variables:
[17:28:39.279]   ..$ a: int [1:3] 1 2 3
[17:28:39.279]   ..$ b: int [1:3] 3 2 1
[17:28:39.279]  - attr(*, "where")=List of 1
[17:28:39.279]   ..$ data:<environment: R_EmptyEnv> 
[17:28:39.279]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:39.279]  - attr(*, "resolved")= logi FALSE
[17:28:39.279]  - attr(*, "total_size")= int 356
[17:28:39.279]  - attr(*, "already-done")= logi TRUE
[17:28:39.284] - copied 'data' to environment
[17:28:39.284] assign_globals() ... done
[17:28:39.285] plan(): Setting new future strategy stack:
[17:28:39.285] List of future strategies:
[17:28:39.285] 1. sequential:
[17:28:39.285]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.285]    - tweaked: FALSE
[17:28:39.285]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.288] plan(): nbrOfWorkers() = 1
[17:28:39.358] plan(): Setting new future strategy stack:
[17:28:39.358] List of future strategies:
[17:28:39.358] 1. sequential:
[17:28:39.358]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.358]    - tweaked: FALSE
[17:28:39.358]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.358] 2. sequential:
[17:28:39.358]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.358]    - tweaked: FALSE
[17:28:39.358]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.360] plan(): nbrOfWorkers() = 1
[17:28:39.360] SequentialFuture started (and completed)
[17:28:39.361] signalConditions() ...
[17:28:39.361]  - include = 'immediateCondition'
[17:28:39.361]  - exclude = 
[17:28:39.361]  - resignal = FALSE
[17:28:39.362]  - Number of conditions: 52
[17:28:39.362] signalConditions() ... done
[17:28:39.362] - Launch lazy future ... done
[17:28:39.363] run() for 'SequentialFuture' ... done
[17:28:39.366] signalConditions() ...
[17:28:39.366]  - include = 'immediateCondition'
[17:28:39.367]  - exclude = 
[17:28:39.367]  - resignal = FALSE
[17:28:39.367]  - Number of conditions: 52
[17:28:39.368] signalConditions() ... done
[17:28:39.368] Future state: 'finished'
[17:28:39.368] signalConditions() ...
[17:28:39.369]  - include = 'condition'
[17:28:39.369]  - exclude = 'immediateCondition'
[17:28:39.369]  - resignal = TRUE
[17:28:39.369]  - Number of conditions: 52
[17:28:39.370]  - Condition #1: 'simpleMessage', 'message', 'condition'
[17:28:39.289] getGlobalsAndPackages() ...
[17:28:39.370]  - Condition #2: 'simpleMessage', 'message', 'condition'
[17:28:39.289] Searching for globals...
[17:28:39.370]  - Condition #3: 'simpleMessage', 'message', 'condition'
[17:28:39.317] - globals found: [4] 'subset', 'data', '==', 'a'
[17:28:39.371]  - Condition #4: 'simpleMessage', 'message', 'condition'
[17:28:39.318] Searching for globals ... DONE
[17:28:39.371]  - Condition #5: 'simpleMessage', 'message', 'condition'
[17:28:39.318] Resolving globals: FALSE
[17:28:39.371]  - Condition #6: 'simpleMessage', 'message', 'condition'
[17:28:39.319] The total size of the 1 globals is 356 bytes (356 bytes)
[17:28:39.372]  - Condition #7: 'simpleMessage', 'message', 'condition'
[17:28:39.320] The total size of the 1 globals exported for future expression ('subset(data, a == 2)') is 356 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (356 bytes of class 'list')
[17:28:39.372]  - Condition #8: 'simpleMessage', 'message', 'condition'
[17:28:39.321] - globals: [1] 'data'
[17:28:39.372]  - Condition #9: 'simpleMessage', 'message', 'condition'
[17:28:39.321] 
[17:28:39.372]  - Condition #10: 'simpleMessage', 'message', 'condition'
[17:28:39.321] getGlobalsAndPackages() ... DONE
[17:28:39.373]  - Condition #11: 'simpleMessage', 'message', 'condition'
[17:28:39.322] run() for 'Future' ...
[17:28:39.373]  - Condition #12: 'simpleMessage', 'message', 'condition'
[17:28:39.323] - state: 'created'
[17:28:39.373]  - Condition #13: 'simpleMessage', 'message', 'condition'
[17:28:39.323] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:39.374]  - Condition #14: 'simpleMessage', 'message', 'condition'
[17:28:39.324] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:39.374]  - Condition #15: 'simpleMessage', 'message', 'condition'
[17:28:39.324] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:39.374]  - Condition #16: 'simpleMessage', 'message', 'condition'
[17:28:39.325]   - Field: 'label'
[17:28:39.375]  - Condition #17: 'simpleMessage', 'message', 'condition'
[17:28:39.325]   - Field: 'local'
[17:28:39.375]  - Condition #18: 'simpleMessage', 'message', 'condition'
[17:28:39.325]   - Field: 'owner'
[17:28:39.375]  - Condition #19: 'simpleMessage', 'message', 'condition'
[17:28:39.326]   - Field: 'envir'
[17:28:39.376]  - Condition #20: 'simpleMessage', 'message', 'condition'
[17:28:39.326]   - Field: 'packages'
[17:28:39.376]  - Condition #21: 'simpleMessage', 'message', 'condition'
[17:28:39.327]   - Field: 'gc'
[17:28:39.376]  - Condition #22: 'simpleMessage', 'message', 'condition'
[17:28:39.327]   - Field: 'conditions'
[17:28:39.376]  - Condition #23: 'simpleMessage', 'message', 'condition'
[17:28:39.327]   - Field: 'expr'
[17:28:39.377]  - Condition #24: 'simpleMessage', 'message', 'condition'
[17:28:39.328]   - Field: 'uuid'
[17:28:39.377]  - Condition #25: 'simpleMessage', 'message', 'condition'
[17:28:39.328]   - Field: 'seed'
[17:28:39.377]  - Condition #26: 'simpleMessage', 'message', 'condition'
[17:28:39.329]   - Field: 'version'
[17:28:39.378]  - Condition #27: 'simpleMessage', 'message', 'condition'
[17:28:39.329]   - Field: 'result'
[17:28:39.378]  - Condition #28: 'simpleMessage', 'message', 'condition'
[17:28:39.329]   - Field: 'asynchronous'
[17:28:39.379]  - Condition #29: 'simpleMessage', 'message', 'condition'
[17:28:39.330]   - Field: 'calls'
[17:28:39.379]  - Condition #30: 'simpleMessage', 'message', 'condition'
[17:28:39.330]   - Field: 'globals'
[17:28:39.379]  - Condition #31: 'simpleMessage', 'message', 'condition'
[17:28:39.331]   - Field: 'stdout'
[17:28:39.380]  - Condition #32: 'simpleMessage', 'message', 'condition'
[17:28:39.331]   - Field: 'earlySignal'
[17:28:39.380]  - Condition #33: 'simpleMessage', 'message', 'condition'
[17:28:39.331]   - Field: 'lazy'
[17:28:39.381]  - Condition #34: 'simpleMessage', 'message', 'condition'
[17:28:39.332]   - Field: 'state'
[17:28:39.381]  - Condition #35: 'simpleMessage', 'message', 'condition'
[17:28:39.332] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:39.381]  - Condition #36: 'simpleMessage', 'message', 'condition'
[17:28:39.333] - Launch lazy future ...
[17:28:39.382]  - Condition #37: 'simpleMessage', 'message', 'condition'
[17:28:39.333] Packages needed by the future expression (n = 0): <none>
[17:28:39.382]  - Condition #38: 'simpleMessage', 'message', 'condition'
[17:28:39.334] Packages needed by future strategies (n = 0): <none>
[17:28:39.382]  - Condition #39: 'simpleMessage', 'message', 'condition'
[17:28:39.335] {
[17:28:39.335]     {
[17:28:39.335]         {
[17:28:39.335]             ...future.startTime <- base::Sys.time()
[17:28:39.335]             {
[17:28:39.335]                 {
[17:28:39.335]                   {
[17:28:39.335]                     base::local({
[17:28:39.335]                       has_future <- base::requireNamespace("future", 
[17:28:39.335]                         quietly = TRUE)
[17:28:39.335]                       if (has_future) {
[17:28:39.335]                         ns <- base::getNamespace("future")
[17:28:39.335]                         version <- ns[[".package"]][["version"]]
[17:28:39.335]                         if (is.null(version)) 
[17:28:39.335]                           version <- utils::packageVersion("future")
[17:28:39.335]                       }
[17:28:39.335]                       else {
[17:28:39.335]                         version <- NULL
[17:28:39.335]                       }
[17:28:39.335]                       if (!has_future || version < "1.8.0") {
[17:28:39.335]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:39.335]                           "", base::R.version$version.string), 
[17:28:39.335]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:39.335]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:39.335]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:39.335]                             "release", "version")], collapse = " "), 
[17:28:39.335]                           hostname = base::Sys.info()[["nodename"]])
[17:28:39.335]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:39.335]                           info)
[17:28:39.335]                         info <- base::paste(info, collapse = "; ")
[17:28:39.335]                         if (!has_future) {
[17:28:39.335]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:39.335]                             info)
[17:28:39.335]                         }
[17:28:39.335]                         else {
[17:28:39.335]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:39.335]                             info, version)
[17:28:39.335]                         }
[17:28:39.335]                         base::stop(msg)
[17:28:39.335]                       }
[17:28:39.335]                     })
[17:28:39.335]                   }
[17:28:39.335]                   ...future.strategy.old <- future::plan("list")
[17:28:39.335]                   options(future.plan = NULL)
[17:28:39.335]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.335]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:39.335]                 }
[17:28:39.335]                 ...future.workdir <- getwd()
[17:28:39.335]             }
[17:28:39.335]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:39.335]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:39.335]         }
[17:28:39.335]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:39.335]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:39.335]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:39.335]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:39.335]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:39.335]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:39.335]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:39.335]             base::names(...future.oldOptions))
[17:28:39.335]     }
[17:28:39.335]     if (FALSE) {
[17:28:39.335]     }
[17:28:39.335]     else {
[17:28:39.335]         if (TRUE) {
[17:28:39.335]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:39.335]                 open = "w")
[17:28:39.335]         }
[17:28:39.335]         else {
[17:28:39.335]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:39.335]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:39.335]         }
[17:28:39.335]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:39.335]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:39.335]             base::sink(type = "output", split = FALSE)
[17:28:39.335]             base::close(...future.stdout)
[17:28:39.335]         }, add = TRUE)
[17:28:39.335]     }
[17:28:39.335]     ...future.frame <- base::sys.nframe()
[17:28:39.335]     ...future.conditions <- base::list()
[17:28:39.335]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:39.335]     if (FALSE) {
[17:28:39.335]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:39.335]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:39.335]     }
[17:28:39.335]     ...future.result <- base::tryCatch({
[17:28:39.335]         base::withCallingHandlers({
[17:28:39.335]             ...future.value <- base::withVisible(base::local(subset(data, 
[17:28:39.335]                 a == 2)))
[17:28:39.335]             future::FutureResult(value = ...future.value$value, 
[17:28:39.335]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.335]                   ...future.rng), globalenv = if (FALSE) 
[17:28:39.335]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:39.335]                     ...future.globalenv.names))
[17:28:39.335]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:39.335]         }, condition = base::local({
[17:28:39.335]             c <- base::c
[17:28:39.335]             inherits <- base::inherits
[17:28:39.335]             invokeRestart <- base::invokeRestart
[17:28:39.335]             length <- base::length
[17:28:39.335]             list <- base::list
[17:28:39.335]             seq.int <- base::seq.int
[17:28:39.335]             signalCondition <- base::signalCondition
[17:28:39.335]             sys.calls <- base::sys.calls
[17:28:39.335]             `[[` <- base::`[[`
[17:28:39.335]             `+` <- base::`+`
[17:28:39.335]             `<<-` <- base::`<<-`
[17:28:39.335]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:39.335]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:39.335]                   3L)]
[17:28:39.335]             }
[17:28:39.335]             function(cond) {
[17:28:39.335]                 is_error <- inherits(cond, "error")
[17:28:39.335]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:39.335]                   NULL)
[17:28:39.335]                 if (is_error) {
[17:28:39.335]                   sessionInformation <- function() {
[17:28:39.335]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:39.335]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:39.335]                       search = base::search(), system = base::Sys.info())
[17:28:39.335]                   }
[17:28:39.335]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.335]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:39.335]                     cond$call), session = sessionInformation(), 
[17:28:39.335]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:39.335]                   signalCondition(cond)
[17:28:39.335]                 }
[17:28:39.335]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:39.335]                 "immediateCondition"))) {
[17:28:39.335]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:39.335]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.335]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:39.335]                   if (TRUE && !signal) {
[17:28:39.335]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.335]                     {
[17:28:39.335]                       inherits <- base::inherits
[17:28:39.335]                       invokeRestart <- base::invokeRestart
[17:28:39.335]                       is.null <- base::is.null
[17:28:39.335]                       muffled <- FALSE
[17:28:39.335]                       if (inherits(cond, "message")) {
[17:28:39.335]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.335]                         if (muffled) 
[17:28:39.335]                           invokeRestart("muffleMessage")
[17:28:39.335]                       }
[17:28:39.335]                       else if (inherits(cond, "warning")) {
[17:28:39.335]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.335]                         if (muffled) 
[17:28:39.335]                           invokeRestart("muffleWarning")
[17:28:39.335]                       }
[17:28:39.335]                       else if (inherits(cond, "condition")) {
[17:28:39.335]                         if (!is.null(pattern)) {
[17:28:39.335]                           computeRestarts <- base::computeRestarts
[17:28:39.335]                           grepl <- base::grepl
[17:28:39.335]                           restarts <- computeRestarts(cond)
[17:28:39.335]                           for (restart in restarts) {
[17:28:39.335]                             name <- restart$name
[17:28:39.335]                             if (is.null(name)) 
[17:28:39.335]                               next
[17:28:39.335]                             if (!grepl(pattern, name)) 
[17:28:39.335]                               next
[17:28:39.335]                             invokeRestart(restart)
[17:28:39.335]                             muffled <- TRUE
[17:28:39.335]                             break
[17:28:39.335]                           }
[17:28:39.335]                         }
[17:28:39.335]                       }
[17:28:39.335]                       invisible(muffled)
[17:28:39.335]                     }
[17:28:39.335]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.335]                   }
[17:28:39.335]                 }
[17:28:39.335]                 else {
[17:28:39.335]                   if (TRUE) {
[17:28:39.335]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.335]                     {
[17:28:39.335]                       inherits <- base::inherits
[17:28:39.335]                       invokeRestart <- base::invokeRestart
[17:28:39.335]                       is.null <- base::is.null
[17:28:39.335]                       muffled <- FALSE
[17:28:39.335]                       if (inherits(cond, "message")) {
[17:28:39.335]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.335]                         if (muffled) 
[17:28:39.335]                           invokeRestart("muffleMessage")
[17:28:39.335]                       }
[17:28:39.335]                       else if (inherits(cond, "warning")) {
[17:28:39.335]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.335]                         if (muffled) 
[17:28:39.335]                           invokeRestart("muffleWarning")
[17:28:39.335]                       }
[17:28:39.335]                       else if (inherits(cond, "condition")) {
[17:28:39.335]                         if (!is.null(pattern)) {
[17:28:39.335]                           computeRestarts <- base::computeRestarts
[17:28:39.335]                           grepl <- base::grepl
[17:28:39.335]                           restarts <- computeRestarts(cond)
[17:28:39.335]                           for (restart in restarts) {
[17:28:39.335]                             name <- restart$name
[17:28:39.335]                             if (is.null(name)) 
[17:28:39.335]                               next
[17:28:39.335]                             if (!grepl(pattern, name)) 
[17:28:39.335]                               next
[17:28:39.335]                             invokeRestart(restart)
[17:28:39.335]                             muffled <- TRUE
[17:28:39.335]                             break
[17:28:39.335]                           }
[17:28:39.335]                         }
[17:28:39.335]                       }
[17:28:39.335]                       invisible(muffled)
[17:28:39.335]                     }
[17:28:39.335]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.335]                   }
[17:28:39.335]                 }
[17:28:39.335]             }
[17:28:39.335]         }))
[17:28:39.335]     }, error = function(ex) {
[17:28:39.335]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:39.335]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.335]                 ...future.rng), started = ...future.startTime, 
[17:28:39.335]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:39.335]             version = "1.8"), class = "FutureResult")
[17:28:39.335]     }, finally = {
[17:28:39.335]         if (!identical(...future.workdir, getwd())) 
[17:28:39.335]             setwd(...future.workdir)
[17:28:39.335]         {
[17:28:39.335]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:39.335]                 ...future.oldOptions$nwarnings <- NULL
[17:28:39.335]             }
[17:28:39.335]             base::options(...future.oldOptions)
[17:28:39.335]             if (.Platform$OS.type == "windows") {
[17:28:39.335]                 old_names <- names(...future.oldEnvVars)
[17:28:39.335]                 envs <- base::Sys.getenv()
[17:28:39.335]                 names <- names(envs)
[17:28:39.335]                 common <- intersect(names, old_names)
[17:28:39.335]                 added <- setdiff(names, old_names)
[17:28:39.335]                 removed <- setdiff(old_names, names)
[17:28:39.335]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:39.335]                   envs[common]]
[17:28:39.335]                 NAMES <- toupper(changed)
[17:28:39.335]                 args <- list()
[17:28:39.335]                 for (kk in seq_along(NAMES)) {
[17:28:39.335]                   name <- changed[[kk]]
[17:28:39.335]                   NAME <- NAMES[[kk]]
[17:28:39.335]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.335]                     next
[17:28:39.335]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.335]                 }
[17:28:39.335]                 NAMES <- toupper(added)
[17:28:39.335]                 for (kk in seq_along(NAMES)) {
[17:28:39.335]                   name <- added[[kk]]
[17:28:39.335]                   NAME <- NAMES[[kk]]
[17:28:39.335]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.335]                     next
[17:28:39.335]                   args[[name]] <- ""
[17:28:39.335]                 }
[17:28:39.335]                 NAMES <- toupper(removed)
[17:28:39.335]                 for (kk in seq_along(NAMES)) {
[17:28:39.335]                   name <- removed[[kk]]
[17:28:39.335]                   NAME <- NAMES[[kk]]
[17:28:39.335]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.335]                     next
[17:28:39.335]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.335]                 }
[17:28:39.335]                 if (length(args) > 0) 
[17:28:39.335]                   base::do.call(base::Sys.setenv, args = args)
[17:28:39.335]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:39.335]             }
[17:28:39.335]             else {
[17:28:39.335]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:39.335]             }
[17:28:39.335]             {
[17:28:39.335]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:39.335]                   0L) {
[17:28:39.335]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:39.335]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:39.335]                   base::options(opts)
[17:28:39.335]                 }
[17:28:39.335]                 {
[17:28:39.335]                   {
[17:28:39.335]                     NULL
[17:28:39.335]                     RNGkind("Mersenne-Twister")
[17:28:39.335]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:39.335]                       inherits = FALSE)
[17:28:39.335]                   }
[17:28:39.335]                   options(future.plan = NULL)
[17:28:39.335]                   if (is.na(NA_character_)) 
[17:28:39.335]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.335]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:39.335]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:39.335]                     .init = FALSE)
[17:28:39.335]                 }
[17:28:39.335]             }
[17:28:39.335]         }
[17:28:39.335]     })
[17:28:39.335]     if (TRUE) {
[17:28:39.335]         base::sink(type = "output", split = FALSE)
[17:28:39.335]         if (TRUE) {
[17:28:39.335]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:39.335]         }
[17:28:39.335]         else {
[17:28:39.335]             ...future.result["stdout"] <- base::list(NULL)
[17:28:39.335]         }
[17:28:39.335]         base::close(...future.stdout)
[17:28:39.335]         ...future.stdout <- NULL
[17:28:39.335]     }
[17:28:39.335]     ...future.result$conditions <- ...future.conditions
[17:28:39.335]     ...future.result$finished <- base::Sys.time()
[17:28:39.335]     ...future.result
[17:28:39.335] }
[17:28:39.383]  - Condition #40: 'simpleMessage', 'message', 'condition'
[17:28:39.341] assign_globals() ...
[17:28:39.383]  - Condition #41: 'simpleMessage', 'message', 'condition'
[17:28:39.342] List of 1
[17:28:39.342]  $ data:'data.frame':	3 obs. of  2 variables:
[17:28:39.342]   ..$ a: int [1:3] 1 2 3
[17:28:39.342]   ..$ b: int [1:3] 3 2 1
[17:28:39.342]  - attr(*, "where")=List of 1
[17:28:39.342]   ..$ data:<environment: R_EmptyEnv> 
[17:28:39.342]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:39.342]  - attr(*, "resolved")= logi FALSE
[17:28:39.342]  - attr(*, "total_size")= int 356
[17:28:39.342]  - attr(*, "already-done")= logi TRUE
[17:28:39.383]  - Condition #42: 'simpleMessage', 'message', 'condition'
[17:28:39.349] - copied 'data' to environment
[17:28:39.384]  - Condition #43: 'simpleMessage', 'message', 'condition'
[17:28:39.349] assign_globals() ... done
[17:28:39.384]  - Condition #44: 'simpleMessage', 'message', 'condition'
[17:28:39.350] plan(): Setting new future strategy stack:
[17:28:39.384]  - Condition #45: 'simpleMessage', 'message', 'condition'
[17:28:39.350] List of future strategies:
[17:28:39.350] 1. sequential:
[17:28:39.350]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.350]    - tweaked: FALSE
[17:28:39.350]    - call: NULL
[17:28:39.385]  - Condition #46: 'simpleMessage', 'message', 'condition'
[17:28:39.351] plan(): nbrOfWorkers() = 1
[17:28:39.385]  - Condition #47: 'simpleMessage', 'message', 'condition'
[17:28:39.354] plan(): Setting new future strategy stack:
[17:28:39.385]  - Condition #48: 'simpleMessage', 'message', 'condition'
[17:28:39.354] List of future strategies:
[17:28:39.354] 1. sequential:
[17:28:39.354]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.354]    - tweaked: FALSE
[17:28:39.354]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.386]  - Condition #49: 'simpleMessage', 'message', 'condition'
[17:28:39.355] plan(): nbrOfWorkers() = 1
[17:28:39.386]  - Condition #50: 'simpleMessage', 'message', 'condition'
[17:28:39.355] SequentialFuture started (and completed)
[17:28:39.386]  - Condition #51: 'simpleMessage', 'message', 'condition'
[17:28:39.356] - Launch lazy future ... done
[17:28:39.387]  - Condition #52: 'simpleMessage', 'message', 'condition'
[17:28:39.356] run() for 'SequentialFuture' ... done
[17:28:39.387] signalConditions() ... done
- plan(list('sequential', 'sequential')) ... DONE
- plan(list('sequential', 'multisession')) ...
[17:28:39.388] plan(): Setting new future strategy stack:
[17:28:39.388] List of future strategies:
[17:28:39.388] 1. sequential:
[17:28:39.388]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:39.388]    - tweaked: FALSE
[17:28:39.388]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.388] 2. multisession:
[17:28:39.388]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:39.388]    - tweaked: FALSE
[17:28:39.388]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.389] plan(): nbrOfWorkers() = 1
[17:28:39.389] getGlobalsAndPackages() ...
[17:28:39.390] Searching for globals...
[17:28:39.433] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[17:28:39.434] Searching for globals ... DONE
[17:28:39.434] Resolving globals: FALSE
[17:28:39.436] The total size of the 2 globals is 7.45 KiB (7631 bytes)
[17:28:39.437] The total size of the 2 globals exported for future expression ('{; a <- 1L; plan_a <- unclass(future::plan("list")); nested_a <- nested[-1]; stopifnot(length(nested_a) == 1L, length(plan_a) == 1L, inherits(plan_a[[1]],; "future"), inherits(future::plan("next"), strategy2)); ...; }; y; }') is 7.45 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (7.40 KiB of class 'list') and 'strategy2' (51 bytes of class 'character')
[17:28:39.438] - globals: [2] 'nested', 'strategy2'
[17:28:39.438] - packages: [1] 'future'
[17:28:39.439] getGlobalsAndPackages() ... DONE
[17:28:39.439] run() for 'Future' ...
[17:28:39.440] - state: 'created'
[17:28:39.440] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:39.441] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:39.441] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:39.441]   - Field: 'label'
[17:28:39.442]   - Field: 'local'
[17:28:39.442]   - Field: 'owner'
[17:28:39.443]   - Field: 'envir'
[17:28:39.443]   - Field: 'packages'
[17:28:39.443]   - Field: 'gc'
[17:28:39.444]   - Field: 'conditions'
[17:28:39.444]   - Field: 'expr'
[17:28:39.444]   - Field: 'uuid'
[17:28:39.445]   - Field: 'seed'
[17:28:39.445]   - Field: 'version'
[17:28:39.445]   - Field: 'result'
[17:28:39.446]   - Field: 'asynchronous'
[17:28:39.446]   - Field: 'calls'
[17:28:39.446]   - Field: 'globals'
[17:28:39.447]   - Field: 'stdout'
[17:28:39.447]   - Field: 'earlySignal'
[17:28:39.447]   - Field: 'lazy'
[17:28:39.448]   - Field: 'state'
[17:28:39.448] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:39.448] - Launch lazy future ...
[17:28:39.449] Packages needed by the future expression (n = 1): 'future'
[17:28:39.449] Packages needed by future strategies (n = 1): 'future'
[17:28:39.451] {
[17:28:39.451]     {
[17:28:39.451]         {
[17:28:39.451]             ...future.startTime <- base::Sys.time()
[17:28:39.451]             {
[17:28:39.451]                 {
[17:28:39.451]                   {
[17:28:39.451]                     {
[17:28:39.451]                       base::local({
[17:28:39.451]                         has_future <- base::requireNamespace("future", 
[17:28:39.451]                           quietly = TRUE)
[17:28:39.451]                         if (has_future) {
[17:28:39.451]                           ns <- base::getNamespace("future")
[17:28:39.451]                           version <- ns[[".package"]][["version"]]
[17:28:39.451]                           if (is.null(version)) 
[17:28:39.451]                             version <- utils::packageVersion("future")
[17:28:39.451]                         }
[17:28:39.451]                         else {
[17:28:39.451]                           version <- NULL
[17:28:39.451]                         }
[17:28:39.451]                         if (!has_future || version < "1.8.0") {
[17:28:39.451]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:39.451]                             "", base::R.version$version.string), 
[17:28:39.451]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:39.451]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:39.451]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:39.451]                               "release", "version")], collapse = " "), 
[17:28:39.451]                             hostname = base::Sys.info()[["nodename"]])
[17:28:39.451]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:39.451]                             info)
[17:28:39.451]                           info <- base::paste(info, collapse = "; ")
[17:28:39.451]                           if (!has_future) {
[17:28:39.451]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:39.451]                               info)
[17:28:39.451]                           }
[17:28:39.451]                           else {
[17:28:39.451]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:39.451]                               info, version)
[17:28:39.451]                           }
[17:28:39.451]                           base::stop(msg)
[17:28:39.451]                         }
[17:28:39.451]                       })
[17:28:39.451]                     }
[17:28:39.451]                     base::local({
[17:28:39.451]                       for (pkg in "future") {
[17:28:39.451]                         base::loadNamespace(pkg)
[17:28:39.451]                         base::library(pkg, character.only = TRUE)
[17:28:39.451]                       }
[17:28:39.451]                     })
[17:28:39.451]                   }
[17:28:39.451]                   ...future.strategy.old <- future::plan("list")
[17:28:39.451]                   options(future.plan = NULL)
[17:28:39.451]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.451]                   future::plan(list(b = function (..., workers = availableCores(), 
[17:28:39.451]                     lazy = FALSE, rscript_libs = .libPaths(), 
[17:28:39.451]                     envir = parent.frame()) 
[17:28:39.451]                   {
[17:28:39.451]                     if (is.function(workers)) 
[17:28:39.451]                       workers <- workers()
[17:28:39.451]                     workers <- structure(as.integer(workers), 
[17:28:39.451]                       class = class(workers))
[17:28:39.451]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[17:28:39.451]                       workers >= 1)
[17:28:39.451]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[17:28:39.451]                       return(sequential(..., lazy = TRUE, envir = envir))
[17:28:39.451]                     }
[17:28:39.451]                     future <- MultisessionFuture(..., workers = workers, 
[17:28:39.451]                       lazy = lazy, rscript_libs = rscript_libs, 
[17:28:39.451]                       envir = envir)
[17:28:39.451]                     if (!future$lazy) 
[17:28:39.451]                       future <- run(future)
[17:28:39.451]                     invisible(future)
[17:28:39.451]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:39.451]                 }
[17:28:39.451]                 ...future.workdir <- getwd()
[17:28:39.451]             }
[17:28:39.451]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:39.451]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:39.451]         }
[17:28:39.451]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:39.451]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:39.451]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:39.451]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:39.451]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:39.451]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:39.451]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:39.451]             base::names(...future.oldOptions))
[17:28:39.451]     }
[17:28:39.451]     if (FALSE) {
[17:28:39.451]     }
[17:28:39.451]     else {
[17:28:39.451]         if (TRUE) {
[17:28:39.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:39.451]                 open = "w")
[17:28:39.451]         }
[17:28:39.451]         else {
[17:28:39.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:39.451]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:39.451]         }
[17:28:39.451]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:39.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:39.451]             base::sink(type = "output", split = FALSE)
[17:28:39.451]             base::close(...future.stdout)
[17:28:39.451]         }, add = TRUE)
[17:28:39.451]     }
[17:28:39.451]     ...future.frame <- base::sys.nframe()
[17:28:39.451]     ...future.conditions <- base::list()
[17:28:39.451]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:39.451]     if (FALSE) {
[17:28:39.451]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:39.451]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:39.451]     }
[17:28:39.451]     ...future.result <- base::tryCatch({
[17:28:39.451]         base::withCallingHandlers({
[17:28:39.451]             ...future.value <- base::withVisible(base::local({
[17:28:39.451]                 a <- 1L
[17:28:39.451]                 plan_a <- unclass(future::plan("list"))
[17:28:39.451]                 nested_a <- nested[-1]
[17:28:39.451]                 stopifnot(length(nested_a) == 1L, length(plan_a) == 
[17:28:39.451]                   1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[17:28:39.451]                   strategy2))
[17:28:39.451]                 for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[17:28:39.451]                   "init") <- NULL
[17:28:39.451]                 for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[17:28:39.451]                   "init") <- NULL
[17:28:39.451]                 stopifnot(all.equal(plan_a, nested_a))
[17:28:39.451]                 y %<-% {
[17:28:39.451]                   b <- 2L
[17:28:39.451]                   plan_b <- future::plan("list")
[17:28:39.451]                   nested_b <- nested_a[-1]
[17:28:39.451]                   stopifnot(length(nested_b) == 0L, length(plan_b) == 
[17:28:39.451]                     1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[17:28:39.451]                     "sequential"))
[17:28:39.451]                   list(a = a, nested_a = nested_a, plan_a = plan_a, 
[17:28:39.451]                     b = b, nested_b = nested_b, plan_b = plan_b)
[17:28:39.451]                 }
[17:28:39.451]                 y
[17:28:39.451]             }))
[17:28:39.451]             future::FutureResult(value = ...future.value$value, 
[17:28:39.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.451]                   ...future.rng), globalenv = if (FALSE) 
[17:28:39.451]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:39.451]                     ...future.globalenv.names))
[17:28:39.451]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:39.451]         }, condition = base::local({
[17:28:39.451]             c <- base::c
[17:28:39.451]             inherits <- base::inherits
[17:28:39.451]             invokeRestart <- base::invokeRestart
[17:28:39.451]             length <- base::length
[17:28:39.451]             list <- base::list
[17:28:39.451]             seq.int <- base::seq.int
[17:28:39.451]             signalCondition <- base::signalCondition
[17:28:39.451]             sys.calls <- base::sys.calls
[17:28:39.451]             `[[` <- base::`[[`
[17:28:39.451]             `+` <- base::`+`
[17:28:39.451]             `<<-` <- base::`<<-`
[17:28:39.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:39.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:39.451]                   3L)]
[17:28:39.451]             }
[17:28:39.451]             function(cond) {
[17:28:39.451]                 is_error <- inherits(cond, "error")
[17:28:39.451]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:39.451]                   NULL)
[17:28:39.451]                 if (is_error) {
[17:28:39.451]                   sessionInformation <- function() {
[17:28:39.451]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:39.451]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:39.451]                       search = base::search(), system = base::Sys.info())
[17:28:39.451]                   }
[17:28:39.451]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:39.451]                     cond$call), session = sessionInformation(), 
[17:28:39.451]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:39.451]                   signalCondition(cond)
[17:28:39.451]                 }
[17:28:39.451]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:39.451]                 "immediateCondition"))) {
[17:28:39.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:39.451]                   ...future.conditions[[length(...future.conditions) + 
[17:28:39.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:39.451]                   if (TRUE && !signal) {
[17:28:39.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.451]                     {
[17:28:39.451]                       inherits <- base::inherits
[17:28:39.451]                       invokeRestart <- base::invokeRestart
[17:28:39.451]                       is.null <- base::is.null
[17:28:39.451]                       muffled <- FALSE
[17:28:39.451]                       if (inherits(cond, "message")) {
[17:28:39.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.451]                         if (muffled) 
[17:28:39.451]                           invokeRestart("muffleMessage")
[17:28:39.451]                       }
[17:28:39.451]                       else if (inherits(cond, "warning")) {
[17:28:39.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.451]                         if (muffled) 
[17:28:39.451]                           invokeRestart("muffleWarning")
[17:28:39.451]                       }
[17:28:39.451]                       else if (inherits(cond, "condition")) {
[17:28:39.451]                         if (!is.null(pattern)) {
[17:28:39.451]                           computeRestarts <- base::computeRestarts
[17:28:39.451]                           grepl <- base::grepl
[17:28:39.451]                           restarts <- computeRestarts(cond)
[17:28:39.451]                           for (restart in restarts) {
[17:28:39.451]                             name <- restart$name
[17:28:39.451]                             if (is.null(name)) 
[17:28:39.451]                               next
[17:28:39.451]                             if (!grepl(pattern, name)) 
[17:28:39.451]                               next
[17:28:39.451]                             invokeRestart(restart)
[17:28:39.451]                             muffled <- TRUE
[17:28:39.451]                             break
[17:28:39.451]                           }
[17:28:39.451]                         }
[17:28:39.451]                       }
[17:28:39.451]                       invisible(muffled)
[17:28:39.451]                     }
[17:28:39.451]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.451]                   }
[17:28:39.451]                 }
[17:28:39.451]                 else {
[17:28:39.451]                   if (TRUE) {
[17:28:39.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:39.451]                     {
[17:28:39.451]                       inherits <- base::inherits
[17:28:39.451]                       invokeRestart <- base::invokeRestart
[17:28:39.451]                       is.null <- base::is.null
[17:28:39.451]                       muffled <- FALSE
[17:28:39.451]                       if (inherits(cond, "message")) {
[17:28:39.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:39.451]                         if (muffled) 
[17:28:39.451]                           invokeRestart("muffleMessage")
[17:28:39.451]                       }
[17:28:39.451]                       else if (inherits(cond, "warning")) {
[17:28:39.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:39.451]                         if (muffled) 
[17:28:39.451]                           invokeRestart("muffleWarning")
[17:28:39.451]                       }
[17:28:39.451]                       else if (inherits(cond, "condition")) {
[17:28:39.451]                         if (!is.null(pattern)) {
[17:28:39.451]                           computeRestarts <- base::computeRestarts
[17:28:39.451]                           grepl <- base::grepl
[17:28:39.451]                           restarts <- computeRestarts(cond)
[17:28:39.451]                           for (restart in restarts) {
[17:28:39.451]                             name <- restart$name
[17:28:39.451]                             if (is.null(name)) 
[17:28:39.451]                               next
[17:28:39.451]                             if (!grepl(pattern, name)) 
[17:28:39.451]                               next
[17:28:39.451]                             invokeRestart(restart)
[17:28:39.451]                             muffled <- TRUE
[17:28:39.451]                             break
[17:28:39.451]                           }
[17:28:39.451]                         }
[17:28:39.451]                       }
[17:28:39.451]                       invisible(muffled)
[17:28:39.451]                     }
[17:28:39.451]                     muffleCondition(cond, pattern = "^muffle")
[17:28:39.451]                   }
[17:28:39.451]                 }
[17:28:39.451]             }
[17:28:39.451]         }))
[17:28:39.451]     }, error = function(ex) {
[17:28:39.451]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:39.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:39.451]                 ...future.rng), started = ...future.startTime, 
[17:28:39.451]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:39.451]             version = "1.8"), class = "FutureResult")
[17:28:39.451]     }, finally = {
[17:28:39.451]         if (!identical(...future.workdir, getwd())) 
[17:28:39.451]             setwd(...future.workdir)
[17:28:39.451]         {
[17:28:39.451]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:39.451]                 ...future.oldOptions$nwarnings <- NULL
[17:28:39.451]             }
[17:28:39.451]             base::options(...future.oldOptions)
[17:28:39.451]             if (.Platform$OS.type == "windows") {
[17:28:39.451]                 old_names <- names(...future.oldEnvVars)
[17:28:39.451]                 envs <- base::Sys.getenv()
[17:28:39.451]                 names <- names(envs)
[17:28:39.451]                 common <- intersect(names, old_names)
[17:28:39.451]                 added <- setdiff(names, old_names)
[17:28:39.451]                 removed <- setdiff(old_names, names)
[17:28:39.451]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:39.451]                   envs[common]]
[17:28:39.451]                 NAMES <- toupper(changed)
[17:28:39.451]                 args <- list()
[17:28:39.451]                 for (kk in seq_along(NAMES)) {
[17:28:39.451]                   name <- changed[[kk]]
[17:28:39.451]                   NAME <- NAMES[[kk]]
[17:28:39.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.451]                     next
[17:28:39.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.451]                 }
[17:28:39.451]                 NAMES <- toupper(added)
[17:28:39.451]                 for (kk in seq_along(NAMES)) {
[17:28:39.451]                   name <- added[[kk]]
[17:28:39.451]                   NAME <- NAMES[[kk]]
[17:28:39.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.451]                     next
[17:28:39.451]                   args[[name]] <- ""
[17:28:39.451]                 }
[17:28:39.451]                 NAMES <- toupper(removed)
[17:28:39.451]                 for (kk in seq_along(NAMES)) {
[17:28:39.451]                   name <- removed[[kk]]
[17:28:39.451]                   NAME <- NAMES[[kk]]
[17:28:39.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:39.451]                     next
[17:28:39.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:39.451]                 }
[17:28:39.451]                 if (length(args) > 0) 
[17:28:39.451]                   base::do.call(base::Sys.setenv, args = args)
[17:28:39.451]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:39.451]             }
[17:28:39.451]             else {
[17:28:39.451]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:39.451]             }
[17:28:39.451]             {
[17:28:39.451]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:39.451]                   0L) {
[17:28:39.451]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:39.451]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:39.451]                   base::options(opts)
[17:28:39.451]                 }
[17:28:39.451]                 {
[17:28:39.451]                   {
[17:28:39.451]                     NULL
[17:28:39.451]                     RNGkind("Mersenne-Twister")
[17:28:39.451]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:39.451]                       inherits = FALSE)
[17:28:39.451]                   }
[17:28:39.451]                   options(future.plan = NULL)
[17:28:39.451]                   if (is.na(NA_character_)) 
[17:28:39.451]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:39.451]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:39.451]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:39.451]                     .init = FALSE)
[17:28:39.451]                 }
[17:28:39.451]             }
[17:28:39.451]         }
[17:28:39.451]     })
[17:28:39.451]     if (TRUE) {
[17:28:39.451]         base::sink(type = "output", split = FALSE)
[17:28:39.451]         if (TRUE) {
[17:28:39.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:39.451]         }
[17:28:39.451]         else {
[17:28:39.451]             ...future.result["stdout"] <- base::list(NULL)
[17:28:39.451]         }
[17:28:39.451]         base::close(...future.stdout)
[17:28:39.451]         ...future.stdout <- NULL
[17:28:39.451]     }
[17:28:39.451]     ...future.result$conditions <- ...future.conditions
[17:28:39.451]     ...future.result$finished <- base::Sys.time()
[17:28:39.451]     ...future.result
[17:28:39.451] }
[17:28:39.459] assign_globals() ...
[17:28:39.459] List of 2
[17:28:39.459]  $ nested   :List of 2
[17:28:39.459]   ..$ a:function (..., envir = parent.frame())  
[17:28:39.459]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[17:28:39.459]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[17:28:39.459]   ..$ b:function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), 
[17:28:39.459]     envir = parent.frame())  
[17:28:39.459]   .. ..- attr(*, "class")= chr [1:5] "multisession" "cluster" "multiprocess" "future" ...
[17:28:39.459]   .. ..- attr(*, "init")= logi TRUE
[17:28:39.459]   .. ..- attr(*, "cleanup")=function ()  
[17:28:39.459]   .. ..- attr(*, "untweakable")= chr "persistent"
[17:28:39.459]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[17:28:39.459]   ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[17:28:39.459]  $ strategy2: chr "multisession"
[17:28:39.459]  - attr(*, "where")=List of 2
[17:28:39.459]   ..$ nested   :<environment: R_EmptyEnv> 
[17:28:39.459]   ..$ strategy2:<environment: R_EmptyEnv> 
[17:28:39.459]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:39.459]  - attr(*, "resolved")= logi FALSE
[17:28:39.459]  - attr(*, "total_size")= int 7631
[17:28:39.459]  - attr(*, "already-done")= logi TRUE
[17:28:39.470] - copied 'nested' to environment
[17:28:39.471] - copied 'strategy2' to environment
[17:28:39.471] assign_globals() ... done
[17:28:39.473] plan(): Setting new future strategy stack:
[17:28:39.473] List of future strategies:
[17:28:39.473] 1. multisession:
[17:28:39.473]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:39.473]    - tweaked: FALSE
[17:28:39.473]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:39.478] plan(): nbrOfWorkers() = 2
[17:28:40.529] plan(): Setting new future strategy stack:
[17:28:40.529] List of future strategies:
[17:28:40.529] 1. sequential:
[17:28:40.529]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:40.529]    - tweaked: FALSE
[17:28:40.529]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.529] 2. multisession:
[17:28:40.529]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:40.529]    - tweaked: FALSE
[17:28:40.529]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.531] plan(): nbrOfWorkers() = 1
[17:28:40.531] SequentialFuture started (and completed)
[17:28:40.532] signalConditions() ...
[17:28:40.532]  - include = 'immediateCondition'
[17:28:40.532]  - exclude = 
[17:28:40.533]  - resignal = FALSE
[17:28:40.533]  - Number of conditions: 98
[17:28:40.534] signalConditions() ... done
[17:28:40.534] - Launch lazy future ... done
[17:28:40.534] run() for 'SequentialFuture' ... done
[17:28:40.535] signalConditions() ...
[17:28:40.535]  - include = 'immediateCondition'
[17:28:40.536]  - exclude = 
[17:28:40.536]  - resignal = FALSE
[17:28:40.536]  - Number of conditions: 98
[17:28:40.537] signalConditions() ... done
[17:28:40.537] Future state: 'finished'
[17:28:40.538] signalConditions() ...
[17:28:40.538]  - include = 'condition'
[17:28:40.538]  - exclude = 'immediateCondition'
[17:28:40.539]  - resignal = TRUE
[17:28:40.539]  - Number of conditions: 98
[17:28:40.539]  - Condition #1: 'simpleMessage', 'message', 'condition'
[17:28:39.483] getGlobalsAndPackages() ...
[17:28:40.540]  - Condition #2: 'simpleMessage', 'message', 'condition'
[17:28:39.483] Searching for globals...
[17:28:40.540]  - Condition #3: 'simpleMessage', 'message', 'condition'
[17:28:39.526] - globals found: [14] '{', '<-', '::', '[', 'nested_a', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'list', 'a', 'plan_a'
[17:28:40.541]  - Condition #4: 'simpleMessage', 'message', 'condition'
[17:28:39.526] Searching for globals ... DONE
[17:28:40.541]  - Condition #5: 'simpleMessage', 'message', 'condition'
[17:28:39.526] Resolving globals: FALSE
[17:28:40.542]  - Condition #6: 'simpleMessage', 'message', 'condition'
[17:28:39.528] The total size of the 3 globals is 11.81 KiB (12089 bytes)
[17:28:40.542]  - Condition #7: 'simpleMessage', 'message', 'condition'
[17:28:39.529] The total size of the 3 globals exported for future expression ('{; b <- 2L; plan_b <- future::plan("list"); nested_b <- nested_a[-1]; stopifnot(length(nested_b) == 0L, length(plan_b) == 1L, inherits(plan_b[[1]],; "future"), inherits(future::plan("next"), "sequential")); list(a = a, nested_a = nested_a, plan_a = plan_a, b = b,; nested_b = nested_b, plan_b = plan_b); }') is 11.81 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'nested_a' (5.89 KiB of class 'list'), 'plan_a' (5.89 KiB of class 'list') and 'a' (35 bytes of class 'numeric')
[17:28:40.543]  - Condition #8: 'simpleMessage', 'message', 'condition'
[17:28:39.529] - globals: [3] 'nested_a', 'a', 'plan_a'
[17:28:40.543]  - Condition #9: 'simpleMessage', 'message', 'condition'
[17:28:39.530] 
[17:28:40.544]  - Condition #10: 'simpleMessage', 'message', 'condition'
[17:28:39.530] getGlobalsAndPackages() ... DONE
[17:28:40.544]  - Condition #11: 'simpleMessage', 'message', 'condition'
[17:28:39.531] run() for 'Future' ...
[17:28:40.545]  - Condition #12: 'simpleMessage', 'message', 'condition'
[17:28:39.531] - state: 'created'
[17:28:40.545]  - Condition #13: 'simpleMessage', 'message', 'condition'
[17:28:39.531] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:40.545]  - Condition #14: 'simpleMessage', 'message', 'condition'
[17:28:39.538] [local output] makeClusterPSOCK() ...
[17:28:40.546]  - Condition #15: 'simpleMessage', 'message', 'condition'
[17:28:39.592] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:40.546]  - Condition #16: 'simpleMessage', 'message', 'condition'
[17:28:39.600] [local output] Base port: 30546
[17:28:40.547]  - Condition #17: 'simpleMessage', 'message', 'condition'
[17:28:39.600] [local output] Getting setup options for 2 cluster nodes ...
[17:28:40.547]  - Condition #18: 'simpleMessage', 'message', 'condition'
[17:28:39.601] [local output]  - Node #1 of 2 ...
[17:28:40.548]  - Condition #19: 'simpleMessage', 'message', 'condition'
[17:28:39.602] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:40.548]  - Condition #20: 'simpleMessage', 'message', 'condition'
[17:28:39.604] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpY1uheY/worker.rank=1.parallelly.parent=108384.1a7606b1a3505.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpY1uheY/worker.rank=1.parallelly.parent=108384.1a7606b1a3505.pid\")"'
[17:28:40.549]  - Condition #21: 'simpleMessage', 'message', 'condition'
[17:28:39.956] - Possible to infer worker's PID: TRUE
[17:28:40.549]  - Condition #22: 'simpleMessage', 'message', 'condition'
[17:28:39.957] [local output] Rscript port: 30546

[17:28:40.549]  - Condition #23: 'simpleMessage', 'message', 'condition'
[17:28:39.958] [local output]  - Node #2 of 2 ...
[17:28:40.550]  - Condition #24: 'simpleMessage', 'message', 'condition'
[17:28:39.959] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:40.550]  - Condition #25: 'simpleMessage', 'message', 'condition'
[17:28:39.961] [local output] Rscript port: 30546

[17:28:40.551]  - Condition #26: 'simpleMessage', 'message', 'condition'
[17:28:39.962] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:40.551]  - Condition #27: 'simpleMessage', 'message', 'condition'
[17:28:39.963] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:40.552]  - Condition #28: 'simpleMessage', 'message', 'condition'
[17:28:39.964] [local output] Setting up PSOCK nodes in parallel
[17:28:40.552]  - Condition #29: 'simpleMessage', 'message', 'condition'
[17:28:39.965] List of 36
[17:28:39.965]  $ worker          : chr "localhost"
[17:28:39.965]   ..- attr(*, "localhost")= logi TRUE
[17:28:39.965]  $ master          : chr "localhost"
[17:28:39.965]  $ port            : int 30546
[17:28:39.965]  $ connectTimeout  : num 120
[17:28:39.965]  $ timeout         : num 120
[17:28:39.965]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:39.965]  $ homogeneous     : logi TRUE
[17:28:39.965]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=nested_futures.R:108384:CRANWIN3"| __truncated__
[17:28:39.965]  $ rscript_envs    : NULL
[17:28:39.965]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:39.965]  $ rscript_startup : NULL
[17:28:39.965]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:28:39.965]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:39.965]  $ methods         : logi TRUE
[17:28:39.965]  $ socketOptions   : chr "no-delay"
[17:28:39.965]  $ useXDR          : logi FALSE
[17:28:39.965]  $ outfile         : chr "/dev/null"
[17:28:39.965]  $ renice          : int NA
[17:28:39.965]  $ rshcmd          : NULL
[17:28:39.965]  $ user            : chr(0) 
[17:28:39.965]  $ revtunnel       : logi FALSE
[17:28:39.965]  $ rshlogfile      : NULL
[17:28:39.965]  $ rshopts         : chr(0) 
[17:28:39.965]  $ rank            : int 1
[17:28:39.965]  $ manual          : logi FALSE
[17:28:39.965]  $ dryrun          : logi FALSE
[17:28:39.965]  $ quiet           : logi FALSE
[17:28:39.965]  $ setup_strategy  : chr "parallel"
[17:28:39.965]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:39.965]  $ pidfile         : chr "D:/temp/RtmpY1uheY/worker.rank=1.parallelly.parent=108384.1a7606b1a3505.pid"
[17:28:39.965]  $ rshcmd_label    : NULL
[17:28:39.965]  $ rsh_call        : NULL
[17:28:39.965]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:39.965]  $ localMachine    : logi TRUE
[17:28:39.965]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:39.965]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:39.965]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:39.965]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:39.965]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:39.965]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:28:39.965]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:28:39.965]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:39.965]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:39.965]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:39.965]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:39.965]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:39.965]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:39.965]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:39.965]  $ arguments       :List of 28
[17:28:39.965]   ..$ worker          : chr "localhost"
[17:28:39.965]   ..$ master          : NULL
[17:28:39.965]   ..$ port            : int 30546
[17:28:39.965]   ..$ connectTimeout  : num 120
[17:28:39.965]   ..$ timeout         : num 120
[17:28:39.965]   ..$ rscript         : NULL
[17:28:39.965]   ..$ homogeneous     : NULL
[17:28:39.965]   ..$ rscript_args    : NULL
[17:28:39.965]   ..$ rscript_envs    : NULL
[17:28:39.965]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:39.965]   ..$ rscript_startup : NULL
[17:28:39.965]   ..$ rscript_sh      : chr "auto"
[17:28:39.965]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:39.965]   ..$ methods         : logi TRUE
[17:28:39.965]   ..$ socketOptions   : chr "no-delay"
[17:28:39.965]   ..$ useXDR          : logi FALSE
[17:28:39.965]   ..$ outfile         : chr "/dev/null"
[17:28:39.965]   ..$ renice          : int NA
[17:28:39.965]   ..$ rshcmd          : NULL
[17:28:39.965]   ..$ user            : NULL
[17:28:39.965]   ..$ revtunnel       : logi NA
[17:28:39.965]   ..$ rshlogfile      : NULL
[17:28:39.965]   ..$ rshopts         : NULL
[17:28:39.965]   ..$ rank            : int 1
[17:28:39.965]   ..$ manual          : logi FALSE
[17:28:39.965]   ..$ dryrun          : logi FALSE
[17:28:39.965]   ..$ quiet           : logi FALSE
[17:28:39.965]   ..$ setup_strategy  : chr "parallel"
[17:28:39.965]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:40.553]  - Condition #30: 'simpleMessage', 'message', 'condition'
[17:28:40.003] [local output] System call to launch all workers:
[17:28:40.553]  - Condition #31: 'simpleMessage', 'message', 'condition'
[17:28:40.004] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=nested_futures.R:108384:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpY1uheY/worker.rank=1.parallelly.parent=108384.1a7606b1a3505.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=30546 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:40.554]  - Condition #32: 'simpleMessage', 'message', 'condition'
[17:28:40.004] [local output] Starting PSOCK main server
[17:28:40.554]  - Condition #33: 'simpleMessage', 'message', 'condition'
[17:28:40.014] [local output] Workers launched
[17:28:40.555]  - Condition #34: 'simpleMessage', 'message', 'condition'
[17:28:40.014] [local output] Waiting for workers to connect back
[17:28:40.555]  - Condition #35: 'simpleMessage', 'message', 'condition'
[17:28:40.014]  - [local output] 0 workers out of 2 ready
[17:28:40.556]  - Condition #36: 'simpleMessage', 'message', 'condition'
[17:28:40.259]  - [local output] 0 workers out of 2 ready
[17:28:40.556]  - Condition #37: 'simpleMessage', 'message', 'condition'
[17:28:40.260]  - [local output] 1 workers out of 2 ready
[17:28:40.556]  - Condition #38: 'simpleMessage', 'message', 'condition'
[17:28:40.261]  - [local output] 2 workers out of 2 ready
[17:28:40.557]  - Condition #39: 'simpleMessage', 'message', 'condition'
[17:28:40.261] [local output] Launching of 2 workers completed
[17:28:40.557]  - Condition #40: 'simpleMessage', 'message', 'condition'
[17:28:40.261] [local output] Number of nodes in cluster: 2
[17:28:40.558]  - Condition #41: 'simpleMessage', 'message', 'condition'
[17:28:40.262] [local output] Collecting session information from 2 workers
[17:28:40.558]  - Condition #42: 'simpleMessage', 'message', 'condition'
[17:28:40.263] [local output]  - Worker #1 of 2
[17:28:40.558]  - Condition #43: 'simpleMessage', 'message', 'condition'
[17:28:40.264] [local output]  - Worker #2 of 2
[17:28:40.559]  - Condition #44: 'simpleMessage', 'message', 'condition'
[17:28:40.264] [local output] makeClusterPSOCK() ... done
[17:28:40.559]  - Condition #45: 'simpleMessage', 'message', 'condition'
[17:28:40.278] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:40.560]  - Condition #46: 'simpleMessage', 'message', 'condition'
[17:28:40.278] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:40.560]  - Condition #47: 'simpleMessage', 'message', 'condition'
[17:28:40.278]   - Field: 'node'
[17:28:40.560]  - Condition #48: 'simpleMessage', 'message', 'condition'
[17:28:40.279]   - Field: 'label'
[17:28:40.561]  - Condition #49: 'simpleMessage', 'message', 'condition'
[17:28:40.279]   - Field: 'local'
[17:28:40.561]  - Condition #50: 'simpleMessage', 'message', 'condition'
[17:28:40.279]   - Field: 'owner'
[17:28:40.562]  - Condition #51: 'simpleMessage', 'message', 'condition'
[17:28:40.279]   - Field: 'envir'
[17:28:40.562]  - Condition #52: 'simpleMessage', 'message', 'condition'
[17:28:40.279]   - Field: 'workers'
[17:28:40.562]  - Condition #53: 'simpleMessage', 'message', 'condition'
[17:28:40.280]   - Field: 'packages'
[17:28:40.563]  - Condition #54: 'simpleMessage', 'message', 'condition'
[17:28:40.280]   - Field: 'gc'
[17:28:40.563]  - Condition #55: 'simpleMessage', 'message', 'condition'
[17:28:40.280]   - Field: 'conditions'
[17:28:40.564]  - Condition #56: 'simpleMessage', 'message', 'condition'
[17:28:40.280]   - Field: 'persistent'
[17:28:40.564]  - Condition #57: 'simpleMessage', 'message', 'condition'
[17:28:40.281]   - Field: 'expr'
[17:28:40.565]  - Condition #58: 'simpleMessage', 'message', 'condition'
[17:28:40.281]   - Field: 'uuid'
[17:28:40.565]  - Condition #59: 'simpleMessage', 'message', 'condition'
[17:28:40.281]   - Field: 'seed'
[17:28:40.566]  - Condition #60: 'simpleMessage', 'message', 'condition'
[17:28:40.281]   - Field: 'version'
[17:28:40.566]  - Condition #61: 'simpleMessage', 'message', 'condition'
[17:28:40.282]   - Field: 'result'
[17:28:40.566]  - Condition #62: 'simpleMessage', 'message', 'condition'
[17:28:40.282]   - Field: 'asynchronous'
[17:28:40.567]  - Condition #63: 'simpleMessage', 'message', 'condition'
[17:28:40.282]   - Field: 'calls'
[17:28:40.567]  - Condition #64: 'simpleMessage', 'message', 'condition'
[17:28:40.282]   - Field: 'globals'
[17:28:40.568]  - Condition #65: 'simpleMessage', 'message', 'condition'
[17:28:40.282]   - Field: 'stdout'
[17:28:40.568]  - Condition #66: 'simpleMessage', 'message', 'condition'
[17:28:40.283]   - Field: 'earlySignal'
[17:28:40.569]  - Condition #67: 'simpleMessage', 'message', 'condition'
[17:28:40.283]   - Field: 'lazy'
[17:28:40.569]  - Condition #68: 'simpleMessage', 'message', 'condition'
[17:28:40.283]   - Field: 'state'
[17:28:40.569]  - Condition #69: 'simpleMessage', 'message', 'condition'
[17:28:40.284] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:40.570]  - Condition #70: 'simpleMessage', 'message', 'condition'
[17:28:40.284] - Launch lazy future ...
[17:28:40.570]  - Condition #71: 'simpleMessage', 'message', 'condition'
[17:28:40.286] Packages needed by the future expression (n = 0): <none>
[17:28:40.571]  - Condition #72: 'simpleMessage', 'message', 'condition'
[17:28:40.286] Packages needed by future strategies (n = 0): <none>
[17:28:40.571]  - Condition #73: 'simpleMessage', 'message', 'condition'
[17:28:40.287] {
[17:28:40.287]     {
[17:28:40.287]         {
[17:28:40.287]             ...future.startTime <- base::Sys.time()
[17:28:40.287]             {
[17:28:40.287]                 {
[17:28:40.287]                   {
[17:28:40.287]                     {
[17:28:40.287]                       base::local({
[17:28:40.287]                         has_future <- base::requireNamespace("future", 
[17:28:40.287]                           quietly = TRUE)
[17:28:40.287]                         if (has_future) {
[17:28:40.287]                           ns <- base::getNamespace("future")
[17:28:40.287]                           version <- ns[[".package"]][["version"]]
[17:28:40.287]                           if (is.null(version)) 
[17:28:40.287]                             version <- utils::packageVersion("future")
[17:28:40.287]                         }
[17:28:40.287]                         else {
[17:28:40.287]                           version <- NULL
[17:28:40.287]                         }
[17:28:40.287]                         if (!has_future || version < "1.8.0") {
[17:28:40.287]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:40.287]                             "", base::R.version$version.string), 
[17:28:40.287]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:40.287]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:40.287]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:40.287]                               "release", "version")], collapse = " "), 
[17:28:40.287]                             hostname = base::Sys.info()[["nodename"]])
[17:28:40.287]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:40.287]                             info)
[17:28:40.287]                           info <- base::paste(info, collapse = "; ")
[17:28:40.287]                           if (!has_future) {
[17:28:40.287]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:40.287]                               info)
[17:28:40.287]                           }
[17:28:40.287]                           else {
[17:28:40.287]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:40.287]                               info, version)
[17:28:40.287]                           }
[17:28:40.287]                           base::stop(msg)
[17:28:40.287]                         }
[17:28:40.287]                       })
[17:28:40.287]                     }
[17:28:40.287]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:40.287]                     base::options(mc.cores = 1L)
[17:28:40.287]                   }
[17:28:40.287]                   ...future.strategy.old <- future::plan("list")
[17:28:40.287]                   options(future.plan = NULL)
[17:28:40.287]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.287]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:40.287]                 }
[17:28:40.287]                 ...future.workdir <- getwd()
[17:28:40.287]             }
[17:28:40.287]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:40.287]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:40.287]         }
[17:28:40.287]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:40.287]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:40.287]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:40.287]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:40.287]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:40.287]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:40.287]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:40.287]             base::names(...future.oldOptions))
[17:28:40.287]     }
[17:28:40.287]     if (FALSE) {
[17:28:40.287]     }
[17:28:40.287]     else {
[17:28:40.287]         if (TRUE) {
[17:28:40.287]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:40.287]                 open = "w")
[17:28:40.287]         }
[17:28:40.287]         else {
[17:28:40.287]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:40.287]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:40.287]         }
[17:28:40.287]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:40.287]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:40.287]             base::sink(type = "output", split = FALSE)
[17:28:40.287]             base::close(...future.stdout)
[17:28:40.287]         }, add = TRUE)
[17:28:40.287]     }
[17:28:40.287]     ...future.frame <- base::sys.nframe()
[17:28:40.287]     ...future.conditions <- base::list()
[17:28:40.287]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:40.287]     if (FALSE) {
[17:28:40.287]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:40.287]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:40.287]     }
[17:28:40.287]     ...future.result <- base::tryCatch({
[17:28:40.287]         base::withCallingHandlers({
[17:28:40.287]             ...future.value <- base::withVisible(base::local({
[17:28:40.287]                 ...future.makeSendCondition <- base::local({
[17:28:40.287]                   sendCondition <- NULL
[17:28:40.287]                   function(frame = 1L) {
[17:28:40.287]                     if (is.function(sendCondition)) 
[17:28:40.287]                       return(sendCondition)
[17:28:40.287]                     ns <- getNamespace("parallel")
[17:28:40.287]                     if (exists("sendData", mode = "function", 
[17:28:40.287]                       envir = ns)) {
[17:28:40.287]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:40.287]                         envir = ns)
[17:28:40.287]                       envir <- sys.frame(frame)
[17:28:40.287]                       master <- NULL
[17:28:40.287]                       while (!identical(envir, .GlobalEnv) && 
[17:28:40.287]                         !identical(envir, emptyenv())) {
[17:28:40.287]                         if (exists("master", mode = "list", envir = envir, 
[17:28:40.287]                           inherits = FALSE)) {
[17:28:40.287]                           master <- get("master", mode = "list", 
[17:28:40.287]                             envir = envir, inherits = FALSE)
[17:28:40.287]                           if (inherits(master, c("SOCKnode", 
[17:28:40.287]                             "SOCK0node"))) {
[17:28:40.287]                             sendCondition <<- function(cond) {
[17:28:40.287]                               data <- list(type = "VALUE", value = cond, 
[17:28:40.287]                                 success = TRUE)
[17:28:40.287]                               parallel_sendData(master, data)
[17:28:40.287]                             }
[17:28:40.287]                             return(sendCondition)
[17:28:40.287]                           }
[17:28:40.287]                         }
[17:28:40.287]                         frame <- frame + 1L
[17:28:40.287]                         envir <- sys.frame(frame)
[17:28:40.287]                       }
[17:28:40.287]                     }
[17:28:40.287]                     sendCondition <<- function(cond) NULL
[17:28:40.287]                   }
[17:28:40.287]                 })
[17:28:40.287]                 withCallingHandlers({
[17:28:40.287]                   {
[17:28:40.287]                     b <- 2L
[17:28:40.287]                     plan_b <- future::plan("list")
[17:28:40.287]                     nested_b <- nested_a[-1]
[17:28:40.287]                     stopifnot(length(nested_b) == 0L, length(plan_b) == 
[17:28:40.287]                       1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[17:28:40.287]                       "sequential"))
[17:28:40.287]                     list(a = a, nested_a = nested_a, plan_a = plan_a, 
[17:28:40.287]                       b = b, nested_b = nested_b, plan_b = plan_b)
[17:28:40.287]                   }
[17:28:40.287]                 }, immediateCondition = function(cond) {
[17:28:40.287]                   sendCondition <- ...future.makeSendCondition()
[17:28:40.287]                   sendCondition(cond)
[17:28:40.287]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.287]                   {
[17:28:40.287]                     inherits <- base::inherits
[17:28:40.287]                     invokeRestart <- base::invokeRestart
[17:28:40.287]                     is.null <- base::is.null
[17:28:40.287]                     muffled <- FALSE
[17:28:40.287]                     if (inherits(cond, "message")) {
[17:28:40.287]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:40.287]                       if (muffled) 
[17:28:40.287]                         invokeRestart("muffleMessage")
[17:28:40.287]                     }
[17:28:40.287]                     else if (inherits(cond, "warning")) {
[17:28:40.287]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:40.287]                       if (muffled) 
[17:28:40.287]                         invokeRestart("muffleWarning")
[17:28:40.287]                     }
[17:28:40.287]                     else if (inherits(cond, "condition")) {
[17:28:40.287]                       if (!is.null(pattern)) {
[17:28:40.287]                         computeRestarts <- base::computeRestarts
[17:28:40.287]                         grepl <- base::grepl
[17:28:40.287]                         restarts <- computeRestarts(cond)
[17:28:40.287]                         for (restart in restarts) {
[17:28:40.287]                           name <- restart$name
[17:28:40.287]                           if (is.null(name)) 
[17:28:40.287]                             next
[17:28:40.287]                           if (!grepl(pattern, name)) 
[17:28:40.287]                             next
[17:28:40.287]                           invokeRestart(restart)
[17:28:40.287]                           muffled <- TRUE
[17:28:40.287]                           break
[17:28:40.287]                         }
[17:28:40.287]                       }
[17:28:40.287]                     }
[17:28:40.287]                     invisible(muffled)
[17:28:40.287]                   }
[17:28:40.287]                   muffleCondition(cond)
[17:28:40.287]                 })
[17:28:40.287]             }))
[17:28:40.287]             future::FutureResult(value = ...future.value$value, 
[17:28:40.287]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.287]                   ...future.rng), globalenv = if (FALSE) 
[17:28:40.287]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:40.287]                     ...future.globalenv.names))
[17:28:40.287]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:40.287]         }, condition = base::local({
[17:28:40.287]             c <- base::c
[17:28:40.287]             inherits <- base::inherits
[17:28:40.287]             invokeRestart <- base::invokeRestart
[17:28:40.287]             length <- base::length
[17:28:40.287]             list <- base::list
[17:28:40.287]             seq.int <- base::seq.int
[17:28:40.287]             signalCondition <- base::signalCondition
[17:28:40.287]             sys.calls <- base::sys.calls
[17:28:40.287]             `[[` <- base::`[[`
[17:28:40.287]             `+` <- base::`+`
[17:28:40.287]             `<<-` <- base::`<<-`
[17:28:40.287]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:40.287]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:40.287]                   3L)]
[17:28:40.287]             }
[17:28:40.287]             function(cond) {
[17:28:40.287]                 is_error <- inherits(cond, "error")
[17:28:40.287]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:40.287]                   NULL)
[17:28:40.287]                 if (is_error) {
[17:28:40.287]                   sessionInformation <- function() {
[17:28:40.287]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:40.287]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:40.287]                       search = base::search(), system = base::Sys.info())
[17:28:40.287]                   }
[17:28:40.287]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.287]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:40.287]                     cond$call), session = sessionInformation(), 
[17:28:40.287]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:40.287]                   signalCondition(cond)
[17:28:40.287]                 }
[17:28:40.287]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:40.287]                 "immediateCondition"))) {
[17:28:40.287]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:40.287]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.287]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:40.287]                   if (TRUE && !signal) {
[17:28:40.287]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.287]                     {
[17:28:40.287]                       inherits <- base::inherits
[17:28:40.287]                       invokeRestart <- base::invokeRestart
[17:28:40.287]                       is.null <- base::is.null
[17:28:40.287]                       muffled <- FALSE
[17:28:40.287]                       if (inherits(cond, "message")) {
[17:28:40.287]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.287]                         if (muffled) 
[17:28:40.287]                           invokeRestart("muffleMessage")
[17:28:40.287]                       }
[17:28:40.287]                       else if (inherits(cond, "warning")) {
[17:28:40.287]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.287]                         if (muffled) 
[17:28:40.287]                           invokeRestart("muffleWarning")
[17:28:40.287]                       }
[17:28:40.287]                       else if (inherits(cond, "condition")) {
[17:28:40.287]                         if (!is.null(pattern)) {
[17:28:40.287]                           computeRestarts <- base::computeRestarts
[17:28:40.287]                           grepl <- base::grepl
[17:28:40.287]                           restarts <- computeRestarts(cond)
[17:28:40.287]                           for (restart in restarts) {
[17:28:40.287]                             name <- restart$name
[17:28:40.287]                             if (is.null(name)) 
[17:28:40.287]                               next
[17:28:40.287]                             if (!grepl(pattern, name)) 
[17:28:40.287]                               next
[17:28:40.287]                             invokeRestart(restart)
[17:28:40.287]                             muffled <- TRUE
[17:28:40.287]                             break
[17:28:40.287]                           }
[17:28:40.287]                         }
[17:28:40.287]                       }
[17:28:40.287]                       invisible(muffled)
[17:28:40.287]                     }
[17:28:40.287]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.287]                   }
[17:28:40.287]                 }
[17:28:40.287]                 else {
[17:28:40.287]                   if (TRUE) {
[17:28:40.287]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.287]                     {
[17:28:40.287]                       inherits <- base::inherits
[17:28:40.287]                       invokeRestart <- base::invokeRestart
[17:28:40.287]                       is.null <- base::is.null
[17:28:40.287]                       muffled <- FALSE
[17:28:40.287]                       if (inherits(cond, "message")) {
[17:28:40.287]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.287]                         if (muffled) 
[17:28:40.287]                           invokeRestart("muffleMessage")
[17:28:40.287]                       }
[17:28:40.287]                       else if (inherits(cond, "warning")) {
[17:28:40.287]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.287]                         if (muffled) 
[17:28:40.287]                           invokeRestart("muffleWarning")
[17:28:40.287]                       }
[17:28:40.287]                       else if (inherits(cond, "condition")) {
[17:28:40.287]                         if (!is.null(pattern)) {
[17:28:40.287]                           computeRestarts <- base::computeRestarts
[17:28:40.287]                           grepl <- base::grepl
[17:28:40.287]                           restarts <- computeRestarts(cond)
[17:28:40.287]                           for (restart in restarts) {
[17:28:40.287]                             name <- restart$name
[17:28:40.287]                             if (is.null(name)) 
[17:28:40.287]                               next
[17:28:40.287]                             if (!grepl(pattern, name)) 
[17:28:40.287]                               next
[17:28:40.287]                             invokeRestart(restart)
[17:28:40.287]                             muffled <- TRUE
[17:28:40.287]                             break
[17:28:40.287]                           }
[17:28:40.287]                         }
[17:28:40.287]                       }
[17:28:40.287]                       invisible(muffled)
[17:28:40.287]                     }
[17:28:40.287]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.287]                   }
[17:28:40.287]                 }
[17:28:40.287]             }
[17:28:40.287]         }))
[17:28:40.287]     }, error = function(ex) {
[17:28:40.287]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:40.287]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.287]                 ...future.rng), started = ...future.startTime, 
[17:28:40.287]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:40.287]             version = "1.8"), class = "FutureResult")
[17:28:40.287]     }, finally = {
[17:28:40.287]         if (!identical(...future.workdir, getwd())) 
[17:28:40.287]             setwd(...future.workdir)
[17:28:40.287]         {
[17:28:40.287]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:40.287]                 ...future.oldOptions$nwarnings <- NULL
[17:28:40.287]             }
[17:28:40.287]             base::options(...future.oldOptions)
[17:28:40.287]             if (.Platform$OS.type == "windows") {
[17:28:40.287]                 old_names <- names(...future.oldEnvVars)
[17:28:40.287]                 envs <- base::Sys.getenv()
[17:28:40.287]                 names <- names(envs)
[17:28:40.287]                 common <- intersect(names, old_names)
[17:28:40.287]                 added <- setdiff(names, old_names)
[17:28:40.287]                 removed <- setdiff(old_names, names)
[17:28:40.287]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:40.287]                   envs[common]]
[17:28:40.287]                 NAMES <- toupper(changed)
[17:28:40.287]                 args <- list()
[17:28:40.287]                 for (kk in seq_along(NAMES)) {
[17:28:40.287]                   name <- changed[[kk]]
[17:28:40.287]                   NAME <- NAMES[[kk]]
[17:28:40.287]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.287]                     next
[17:28:40.287]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.287]                 }
[17:28:40.287]                 NAMES <- toupper(added)
[17:28:40.287]                 for (kk in seq_along(NAMES)) {
[17:28:40.287]                   name <- added[[kk]]
[17:28:40.287]                   NAME <- NAMES[[kk]]
[17:28:40.287]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.287]                     next
[17:28:40.287]                   args[[name]] <- ""
[17:28:40.287]                 }
[17:28:40.287]                 NAMES <- toupper(removed)
[17:28:40.287]                 for (kk in seq_along(NAMES)) {
[17:28:40.287]                   name <- removed[[kk]]
[17:28:40.287]                   NAME <- NAMES[[kk]]
[17:28:40.287]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.287]                     next
[17:28:40.287]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.287]                 }
[17:28:40.287]                 if (length(args) > 0) 
[17:28:40.287]                   base::do.call(base::Sys.setenv, args = args)
[17:28:40.287]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:40.287]             }
[17:28:40.287]             else {
[17:28:40.287]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:40.287]             }
[17:28:40.287]             {
[17:28:40.287]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:40.287]                   0L) {
[17:28:40.287]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:40.287]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:40.287]                   base::options(opts)
[17:28:40.287]                 }
[17:28:40.287]                 {
[17:28:40.287]                   {
[17:28:40.287]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:40.287]                     NULL
[17:28:40.287]                   }
[17:28:40.287]                   options(future.plan = NULL)
[17:28:40.287]                   if (is.na(NA_character_)) 
[17:28:40.287]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.287]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:40.287]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:40.287]                     .init = FALSE)
[17:28:40.287]                 }
[17:28:40.287]             }
[17:28:40.287]         }
[17:28:40.287]     })
[17:28:40.287]     if (TRUE) {
[17:28:40.287]         base::sink(type = "output", split = FALSE)
[17:28:40.287]         if (TRUE) {
[17:28:40.287]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:40.287]         }
[17:28:40.287]         else {
[17:28:40.287]             ...future.result["stdout"] <- base::list(NULL)
[17:28:40.287]         }
[17:28:40.287]         base::close(...future.stdout)
[17:28:40.287]         ...future.stdout <- NULL
[17:28:40.287]     }
[17:28:40.287]     ...future.result$conditions <- ...future.conditions
[17:28:40.287]     ...future.result$finished <- base::Sys.time()
[17:28:40.287]     ...future.result
[17:28:40.287] }
[17:28:40.572]  - Condition #74: 'simpleMessage', 'message', 'condition'
[17:28:40.438] Exporting 3 global objects (11.46 KiB) to cluster node #1 ...
[17:28:40.572]  - Condition #75: 'simpleMessage', 'message', 'condition'
[17:28:40.438] Exporting 'nested_a' (5.89 KiB) to cluster node #1 ...
[17:28:40.573]  - Condition #76: 'simpleMessage', 'message', 'condition'
[17:28:40.439] Exporting 'nested_a' (5.89 KiB) to cluster node #1 ... DONE
[17:28:40.573]  - Condition #77: 'simpleMessage', 'message', 'condition'
[17:28:40.440] Exporting 'a' (35 bytes) to cluster node #1 ...
[17:28:40.574]  - Condition #78: 'simpleMessage', 'message', 'condition'
[17:28:40.441] Exporting 'a' (35 bytes) to cluster node #1 ... DONE
[17:28:40.574]  - Condition #79: 'simpleMessage', 'message', 'condition'
[17:28:40.442] Exporting 'plan_a' (5.89 KiB) to cluster node #1 ...
[17:28:40.575]  - Condition #80: 'simpleMessage', 'message', 'condition'
[17:28:40.443] Exporting 'plan_a' (5.89 KiB) to cluster node #1 ... DONE
[17:28:40.575]  - Condition #81: 'simpleMessage', 'message', 'condition'
[17:28:40.443] Exporting 3 global objects (11.46 KiB) to cluster node #1 ... DONE
[17:28:40.576]  - Condition #82: 'simpleMessage', 'message', 'condition'
[17:28:40.444] MultisessionFuture started
[17:28:40.576]  - Condition #83: 'simpleMessage', 'message', 'condition'
[17:28:40.445] - Launch lazy future ... done
[17:28:40.577]  - Condition #84: 'simpleMessage', 'message', 'condition'
[17:28:40.445] run() for 'MultisessionFuture' ... done
[17:28:40.577]  - Condition #85: 'simpleMessage', 'message', 'condition'
[17:28:40.445] result() for ClusterFuture ...
[17:28:40.578]  - Condition #86: 'simpleMessage', 'message', 'condition'
[17:28:40.446] receiveMessageFromWorker() for ClusterFuture ...
[17:28:40.578]  - Condition #87: 'simpleMessage', 'message', 'condition'
[17:28:40.446] - Validating connection of MultisessionFuture
[17:28:40.578]  - Condition #88: 'simpleMessage', 'message', 'condition'
[17:28:40.517] - received message: FutureResult
[17:28:40.579]  - Condition #89: 'simpleMessage', 'message', 'condition'
[17:28:40.518] - Received FutureResult
[17:28:40.579]  - Condition #90: 'simpleMessage', 'message', 'condition'
[17:28:40.524] - Erased future from FutureRegistry
[17:28:40.580]  - Condition #91: 'simpleMessage', 'message', 'condition'
[17:28:40.524] result() for ClusterFuture ...
[17:28:40.580]  - Condition #92: 'simpleMessage', 'message', 'condition'
[17:28:40.525] - result already collected: FutureResult
[17:28:40.581]  - Condition #93: 'simpleMessage', 'message', 'condition'
[17:28:40.525] result() for ClusterFuture ... done
[17:28:40.581]  - Condition #94: 'simpleMessage', 'message', 'condition'
[17:28:40.526] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:40.582]  - Condition #95: 'simpleMessage', 'message', 'condition'
[17:28:40.526] result() for ClusterFuture ... done
[17:28:40.582]  - Condition #96: 'simpleMessage', 'message', 'condition'
[17:28:40.526] result() for ClusterFuture ...
[17:28:40.583]  - Condition #97: 'simpleMessage', 'message', 'condition'
[17:28:40.527] - result already collected: FutureResult
[17:28:40.583]  - Condition #98: 'simpleMessage', 'message', 'condition'
[17:28:40.527] result() for ClusterFuture ... done
[17:28:40.584] signalConditions() ... done
List of 6
 $ a       : int 1
 $ nested_a:List of 1
  ..$ b:function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), 
    envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:5] "multisession" "cluster" "multiprocess" "future" ...
  .. ..- attr(*, "cleanup")=function ()  
  .. ..- attr(*, "untweakable")= chr "persistent"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ plan_a  :List of 1
  ..$ b:function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), 
    envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:5] "multisession" "cluster" "multiprocess" "future" ...
  .. ..- attr(*, "cleanup")=function ()  
  .. ..- attr(*, "untweakable")= chr "persistent"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ b       : int 2
 $ nested_b: Named list()
 $ plan_b  :List of 1
  ..$ :function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[17:28:40.600] getGlobalsAndPackages() ...
[17:28:40.600] Searching for globals...
[17:28:40.605] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[17:28:40.605] Searching for globals ... DONE
[17:28:40.606] Resolving globals: FALSE
[17:28:40.607] The total size of the 1 globals is 356 bytes (356 bytes)
[17:28:40.608] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 356 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (356 bytes of class 'list')
[17:28:40.609] - globals: [1] 'data'
[17:28:40.609] - packages: [1] 'future'
[17:28:40.610] getGlobalsAndPackages() ... DONE
[17:28:40.611] run() for 'Future' ...
[17:28:40.611] - state: 'created'
[17:28:40.612] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:40.613] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:40.613] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:40.614]   - Field: 'label'
[17:28:40.614]   - Field: 'local'
[17:28:40.615]   - Field: 'owner'
[17:28:40.615]   - Field: 'envir'
[17:28:40.616]   - Field: 'packages'
[17:28:40.616]   - Field: 'gc'
[17:28:40.617]   - Field: 'conditions'
[17:28:40.617]   - Field: 'expr'
[17:28:40.618]   - Field: 'uuid'
[17:28:40.618]   - Field: 'seed'
[17:28:40.618]   - Field: 'version'
[17:28:40.619]   - Field: 'result'
[17:28:40.619]   - Field: 'asynchronous'
[17:28:40.620]   - Field: 'calls'
[17:28:40.620]   - Field: 'globals'
[17:28:40.621]   - Field: 'stdout'
[17:28:40.621]   - Field: 'earlySignal'
[17:28:40.622]   - Field: 'lazy'
[17:28:40.622]   - Field: 'state'
[17:28:40.623] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:40.623] - Launch lazy future ...
[17:28:40.624] Packages needed by the future expression (n = 1): 'future'
[17:28:40.624] Packages needed by future strategies (n = 1): 'future'
[17:28:40.626] {
[17:28:40.626]     {
[17:28:40.626]         {
[17:28:40.626]             ...future.startTime <- base::Sys.time()
[17:28:40.626]             {
[17:28:40.626]                 {
[17:28:40.626]                   {
[17:28:40.626]                     {
[17:28:40.626]                       base::local({
[17:28:40.626]                         has_future <- base::requireNamespace("future", 
[17:28:40.626]                           quietly = TRUE)
[17:28:40.626]                         if (has_future) {
[17:28:40.626]                           ns <- base::getNamespace("future")
[17:28:40.626]                           version <- ns[[".package"]][["version"]]
[17:28:40.626]                           if (is.null(version)) 
[17:28:40.626]                             version <- utils::packageVersion("future")
[17:28:40.626]                         }
[17:28:40.626]                         else {
[17:28:40.626]                           version <- NULL
[17:28:40.626]                         }
[17:28:40.626]                         if (!has_future || version < "1.8.0") {
[17:28:40.626]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:40.626]                             "", base::R.version$version.string), 
[17:28:40.626]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:40.626]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:40.626]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:40.626]                               "release", "version")], collapse = " "), 
[17:28:40.626]                             hostname = base::Sys.info()[["nodename"]])
[17:28:40.626]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:40.626]                             info)
[17:28:40.626]                           info <- base::paste(info, collapse = "; ")
[17:28:40.626]                           if (!has_future) {
[17:28:40.626]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:40.626]                               info)
[17:28:40.626]                           }
[17:28:40.626]                           else {
[17:28:40.626]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:40.626]                               info, version)
[17:28:40.626]                           }
[17:28:40.626]                           base::stop(msg)
[17:28:40.626]                         }
[17:28:40.626]                       })
[17:28:40.626]                     }
[17:28:40.626]                     base::local({
[17:28:40.626]                       for (pkg in "future") {
[17:28:40.626]                         base::loadNamespace(pkg)
[17:28:40.626]                         base::library(pkg, character.only = TRUE)
[17:28:40.626]                       }
[17:28:40.626]                     })
[17:28:40.626]                   }
[17:28:40.626]                   ...future.strategy.old <- future::plan("list")
[17:28:40.626]                   options(future.plan = NULL)
[17:28:40.626]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.626]                   future::plan(list(b = function (..., workers = availableCores(), 
[17:28:40.626]                     lazy = FALSE, rscript_libs = .libPaths(), 
[17:28:40.626]                     envir = parent.frame()) 
[17:28:40.626]                   {
[17:28:40.626]                     if (is.function(workers)) 
[17:28:40.626]                       workers <- workers()
[17:28:40.626]                     workers <- structure(as.integer(workers), 
[17:28:40.626]                       class = class(workers))
[17:28:40.626]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[17:28:40.626]                       workers >= 1)
[17:28:40.626]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[17:28:40.626]                       return(sequential(..., lazy = TRUE, envir = envir))
[17:28:40.626]                     }
[17:28:40.626]                     future <- MultisessionFuture(..., workers = workers, 
[17:28:40.626]                       lazy = lazy, rscript_libs = rscript_libs, 
[17:28:40.626]                       envir = envir)
[17:28:40.626]                     if (!future$lazy) 
[17:28:40.626]                       future <- run(future)
[17:28:40.626]                     invisible(future)
[17:28:40.626]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:40.626]                 }
[17:28:40.626]                 ...future.workdir <- getwd()
[17:28:40.626]             }
[17:28:40.626]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:40.626]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:40.626]         }
[17:28:40.626]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:40.626]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:40.626]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:40.626]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:40.626]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:40.626]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:40.626]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:40.626]             base::names(...future.oldOptions))
[17:28:40.626]     }
[17:28:40.626]     if (FALSE) {
[17:28:40.626]     }
[17:28:40.626]     else {
[17:28:40.626]         if (TRUE) {
[17:28:40.626]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:40.626]                 open = "w")
[17:28:40.626]         }
[17:28:40.626]         else {
[17:28:40.626]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:40.626]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:40.626]         }
[17:28:40.626]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:40.626]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:40.626]             base::sink(type = "output", split = FALSE)
[17:28:40.626]             base::close(...future.stdout)
[17:28:40.626]         }, add = TRUE)
[17:28:40.626]     }
[17:28:40.626]     ...future.frame <- base::sys.nframe()
[17:28:40.626]     ...future.conditions <- base::list()
[17:28:40.626]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:40.626]     if (FALSE) {
[17:28:40.626]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:40.626]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:40.626]     }
[17:28:40.626]     ...future.result <- base::tryCatch({
[17:28:40.626]         base::withCallingHandlers({
[17:28:40.626]             ...future.value <- base::withVisible(base::local({
[17:28:40.626]                 value(future(subset(data, a == 2)))
[17:28:40.626]             }))
[17:28:40.626]             future::FutureResult(value = ...future.value$value, 
[17:28:40.626]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.626]                   ...future.rng), globalenv = if (FALSE) 
[17:28:40.626]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:40.626]                     ...future.globalenv.names))
[17:28:40.626]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:40.626]         }, condition = base::local({
[17:28:40.626]             c <- base::c
[17:28:40.626]             inherits <- base::inherits
[17:28:40.626]             invokeRestart <- base::invokeRestart
[17:28:40.626]             length <- base::length
[17:28:40.626]             list <- base::list
[17:28:40.626]             seq.int <- base::seq.int
[17:28:40.626]             signalCondition <- base::signalCondition
[17:28:40.626]             sys.calls <- base::sys.calls
[17:28:40.626]             `[[` <- base::`[[`
[17:28:40.626]             `+` <- base::`+`
[17:28:40.626]             `<<-` <- base::`<<-`
[17:28:40.626]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:40.626]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:40.626]                   3L)]
[17:28:40.626]             }
[17:28:40.626]             function(cond) {
[17:28:40.626]                 is_error <- inherits(cond, "error")
[17:28:40.626]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:40.626]                   NULL)
[17:28:40.626]                 if (is_error) {
[17:28:40.626]                   sessionInformation <- function() {
[17:28:40.626]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:40.626]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:40.626]                       search = base::search(), system = base::Sys.info())
[17:28:40.626]                   }
[17:28:40.626]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.626]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:40.626]                     cond$call), session = sessionInformation(), 
[17:28:40.626]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:40.626]                   signalCondition(cond)
[17:28:40.626]                 }
[17:28:40.626]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:40.626]                 "immediateCondition"))) {
[17:28:40.626]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:40.626]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.626]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:40.626]                   if (TRUE && !signal) {
[17:28:40.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.626]                     {
[17:28:40.626]                       inherits <- base::inherits
[17:28:40.626]                       invokeRestart <- base::invokeRestart
[17:28:40.626]                       is.null <- base::is.null
[17:28:40.626]                       muffled <- FALSE
[17:28:40.626]                       if (inherits(cond, "message")) {
[17:28:40.626]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.626]                         if (muffled) 
[17:28:40.626]                           invokeRestart("muffleMessage")
[17:28:40.626]                       }
[17:28:40.626]                       else if (inherits(cond, "warning")) {
[17:28:40.626]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.626]                         if (muffled) 
[17:28:40.626]                           invokeRestart("muffleWarning")
[17:28:40.626]                       }
[17:28:40.626]                       else if (inherits(cond, "condition")) {
[17:28:40.626]                         if (!is.null(pattern)) {
[17:28:40.626]                           computeRestarts <- base::computeRestarts
[17:28:40.626]                           grepl <- base::grepl
[17:28:40.626]                           restarts <- computeRestarts(cond)
[17:28:40.626]                           for (restart in restarts) {
[17:28:40.626]                             name <- restart$name
[17:28:40.626]                             if (is.null(name)) 
[17:28:40.626]                               next
[17:28:40.626]                             if (!grepl(pattern, name)) 
[17:28:40.626]                               next
[17:28:40.626]                             invokeRestart(restart)
[17:28:40.626]                             muffled <- TRUE
[17:28:40.626]                             break
[17:28:40.626]                           }
[17:28:40.626]                         }
[17:28:40.626]                       }
[17:28:40.626]                       invisible(muffled)
[17:28:40.626]                     }
[17:28:40.626]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.626]                   }
[17:28:40.626]                 }
[17:28:40.626]                 else {
[17:28:40.626]                   if (TRUE) {
[17:28:40.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.626]                     {
[17:28:40.626]                       inherits <- base::inherits
[17:28:40.626]                       invokeRestart <- base::invokeRestart
[17:28:40.626]                       is.null <- base::is.null
[17:28:40.626]                       muffled <- FALSE
[17:28:40.626]                       if (inherits(cond, "message")) {
[17:28:40.626]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.626]                         if (muffled) 
[17:28:40.626]                           invokeRestart("muffleMessage")
[17:28:40.626]                       }
[17:28:40.626]                       else if (inherits(cond, "warning")) {
[17:28:40.626]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.626]                         if (muffled) 
[17:28:40.626]                           invokeRestart("muffleWarning")
[17:28:40.626]                       }
[17:28:40.626]                       else if (inherits(cond, "condition")) {
[17:28:40.626]                         if (!is.null(pattern)) {
[17:28:40.626]                           computeRestarts <- base::computeRestarts
[17:28:40.626]                           grepl <- base::grepl
[17:28:40.626]                           restarts <- computeRestarts(cond)
[17:28:40.626]                           for (restart in restarts) {
[17:28:40.626]                             name <- restart$name
[17:28:40.626]                             if (is.null(name)) 
[17:28:40.626]                               next
[17:28:40.626]                             if (!grepl(pattern, name)) 
[17:28:40.626]                               next
[17:28:40.626]                             invokeRestart(restart)
[17:28:40.626]                             muffled <- TRUE
[17:28:40.626]                             break
[17:28:40.626]                           }
[17:28:40.626]                         }
[17:28:40.626]                       }
[17:28:40.626]                       invisible(muffled)
[17:28:40.626]                     }
[17:28:40.626]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.626]                   }
[17:28:40.626]                 }
[17:28:40.626]             }
[17:28:40.626]         }))
[17:28:40.626]     }, error = function(ex) {
[17:28:40.626]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:40.626]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.626]                 ...future.rng), started = ...future.startTime, 
[17:28:40.626]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:40.626]             version = "1.8"), class = "FutureResult")
[17:28:40.626]     }, finally = {
[17:28:40.626]         if (!identical(...future.workdir, getwd())) 
[17:28:40.626]             setwd(...future.workdir)
[17:28:40.626]         {
[17:28:40.626]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:40.626]                 ...future.oldOptions$nwarnings <- NULL
[17:28:40.626]             }
[17:28:40.626]             base::options(...future.oldOptions)
[17:28:40.626]             if (.Platform$OS.type == "windows") {
[17:28:40.626]                 old_names <- names(...future.oldEnvVars)
[17:28:40.626]                 envs <- base::Sys.getenv()
[17:28:40.626]                 names <- names(envs)
[17:28:40.626]                 common <- intersect(names, old_names)
[17:28:40.626]                 added <- setdiff(names, old_names)
[17:28:40.626]                 removed <- setdiff(old_names, names)
[17:28:40.626]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:40.626]                   envs[common]]
[17:28:40.626]                 NAMES <- toupper(changed)
[17:28:40.626]                 args <- list()
[17:28:40.626]                 for (kk in seq_along(NAMES)) {
[17:28:40.626]                   name <- changed[[kk]]
[17:28:40.626]                   NAME <- NAMES[[kk]]
[17:28:40.626]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.626]                     next
[17:28:40.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.626]                 }
[17:28:40.626]                 NAMES <- toupper(added)
[17:28:40.626]                 for (kk in seq_along(NAMES)) {
[17:28:40.626]                   name <- added[[kk]]
[17:28:40.626]                   NAME <- NAMES[[kk]]
[17:28:40.626]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.626]                     next
[17:28:40.626]                   args[[name]] <- ""
[17:28:40.626]                 }
[17:28:40.626]                 NAMES <- toupper(removed)
[17:28:40.626]                 for (kk in seq_along(NAMES)) {
[17:28:40.626]                   name <- removed[[kk]]
[17:28:40.626]                   NAME <- NAMES[[kk]]
[17:28:40.626]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.626]                     next
[17:28:40.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.626]                 }
[17:28:40.626]                 if (length(args) > 0) 
[17:28:40.626]                   base::do.call(base::Sys.setenv, args = args)
[17:28:40.626]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:40.626]             }
[17:28:40.626]             else {
[17:28:40.626]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:40.626]             }
[17:28:40.626]             {
[17:28:40.626]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:40.626]                   0L) {
[17:28:40.626]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:40.626]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:40.626]                   base::options(opts)
[17:28:40.626]                 }
[17:28:40.626]                 {
[17:28:40.626]                   {
[17:28:40.626]                     NULL
[17:28:40.626]                     RNGkind("Mersenne-Twister")
[17:28:40.626]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:40.626]                       inherits = FALSE)
[17:28:40.626]                   }
[17:28:40.626]                   options(future.plan = NULL)
[17:28:40.626]                   if (is.na(NA_character_)) 
[17:28:40.626]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.626]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:40.626]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:40.626]                     .init = FALSE)
[17:28:40.626]                 }
[17:28:40.626]             }
[17:28:40.626]         }
[17:28:40.626]     })
[17:28:40.626]     if (TRUE) {
[17:28:40.626]         base::sink(type = "output", split = FALSE)
[17:28:40.626]         if (TRUE) {
[17:28:40.626]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:40.626]         }
[17:28:40.626]         else {
[17:28:40.626]             ...future.result["stdout"] <- base::list(NULL)
[17:28:40.626]         }
[17:28:40.626]         base::close(...future.stdout)
[17:28:40.626]         ...future.stdout <- NULL
[17:28:40.626]     }
[17:28:40.626]     ...future.result$conditions <- ...future.conditions
[17:28:40.626]     ...future.result$finished <- base::Sys.time()
[17:28:40.626]     ...future.result
[17:28:40.626] }
[17:28:40.634] assign_globals() ...
[17:28:40.634] List of 1
[17:28:40.634]  $ data:'data.frame':	3 obs. of  2 variables:
[17:28:40.634]   ..$ a: int [1:3] 1 2 3
[17:28:40.634]   ..$ b: int [1:3] 3 2 1
[17:28:40.634]  - attr(*, "where")=List of 1
[17:28:40.634]   ..$ data:<environment: R_EmptyEnv> 
[17:28:40.634]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:40.634]  - attr(*, "resolved")= logi FALSE
[17:28:40.634]  - attr(*, "total_size")= int 356
[17:28:40.634]  - attr(*, "already-done")= logi TRUE
[17:28:40.645] - copied 'data' to environment
[17:28:40.645] assign_globals() ... done
[17:28:40.646] plan(): Setting new future strategy stack:
[17:28:40.646] List of future strategies:
[17:28:40.646] 1. multisession:
[17:28:40.646]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:40.646]    - tweaked: FALSE
[17:28:40.646]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.650] plan(): nbrOfWorkers() = 2
[17:28:40.757] plan(): Setting new future strategy stack:
[17:28:40.757] List of future strategies:
[17:28:40.757] 1. sequential:
[17:28:40.757]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:40.757]    - tweaked: FALSE
[17:28:40.757]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.757] 2. multisession:
[17:28:40.757]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:40.757]    - tweaked: FALSE
[17:28:40.757]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.758] plan(): nbrOfWorkers() = 1
[17:28:40.759] SequentialFuture started (and completed)
[17:28:40.759] signalConditions() ...
[17:28:40.759]  - include = 'immediateCondition'
[17:28:40.760]  - exclude = 
[17:28:40.760]  - resignal = FALSE
[17:28:40.760]  - Number of conditions: 63
[17:28:40.761] signalConditions() ... done
[17:28:40.761] - Launch lazy future ... done
[17:28:40.761] run() for 'SequentialFuture' ... done
[17:28:40.762] signalConditions() ...
[17:28:40.762]  - include = 'immediateCondition'
[17:28:40.763]  - exclude = 
[17:28:40.763]  - resignal = FALSE
[17:28:40.763]  - Number of conditions: 63
[17:28:40.764] signalConditions() ... done
[17:28:40.764] Future state: 'finished'
[17:28:40.764] signalConditions() ...
[17:28:40.765]  - include = 'condition'
[17:28:40.765]  - exclude = 'immediateCondition'
[17:28:40.765]  - resignal = TRUE
[17:28:40.766]  - Number of conditions: 63
[17:28:40.766]  - Condition #1: 'simpleMessage', 'message', 'condition'
[17:28:40.651] getGlobalsAndPackages() ...
[17:28:40.766]  - Condition #2: 'simpleMessage', 'message', 'condition'
[17:28:40.652] Searching for globals...
[17:28:40.767]  - Condition #3: 'simpleMessage', 'message', 'condition'
[17:28:40.680] - globals found: [4] 'subset', 'data', '==', 'a'
[17:28:40.767]  - Condition #4: 'simpleMessage', 'message', 'condition'
[17:28:40.681] Searching for globals ... DONE
[17:28:40.767]  - Condition #5: 'simpleMessage', 'message', 'condition'
[17:28:40.681] Resolving globals: FALSE
[17:28:40.768]  - Condition #6: 'simpleMessage', 'message', 'condition'
[17:28:40.682] The total size of the 1 globals is 356 bytes (356 bytes)
[17:28:40.768]  - Condition #7: 'simpleMessage', 'message', 'condition'
[17:28:40.683] The total size of the 1 globals exported for future expression ('subset(data, a == 2)') is 356 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (356 bytes of class 'list')
[17:28:40.769]  - Condition #8: 'simpleMessage', 'message', 'condition'
[17:28:40.683] - globals: [1] 'data'
[17:28:40.769]  - Condition #9: 'simpleMessage', 'message', 'condition'
[17:28:40.683] 
[17:28:40.769]  - Condition #10: 'simpleMessage', 'message', 'condition'
[17:28:40.684] getGlobalsAndPackages() ... DONE
[17:28:40.770]  - Condition #11: 'simpleMessage', 'message', 'condition'
[17:28:40.684] run() for 'Future' ...
[17:28:40.770]  - Condition #12: 'simpleMessage', 'message', 'condition'
[17:28:40.685] - state: 'created'
[17:28:40.771]  - Condition #13: 'simpleMessage', 'message', 'condition'
[17:28:40.685] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:40.771]  - Condition #14: 'simpleMessage', 'message', 'condition'
[17:28:40.704] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:40.771]  - Condition #15: 'simpleMessage', 'message', 'condition'
[17:28:40.705] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:40.772]  - Condition #16: 'simpleMessage', 'message', 'condition'
[17:28:40.705]   - Field: 'node'
[17:28:40.772]  - Condition #17: 'simpleMessage', 'message', 'condition'
[17:28:40.706]   - Field: 'label'
[17:28:40.773]  - Condition #18: 'simpleMessage', 'message', 'condition'
[17:28:40.706]   - Field: 'local'
[17:28:40.773]  - Condition #19: 'simpleMessage', 'message', 'condition'
[17:28:40.706]   - Field: 'owner'
[17:28:40.773]  - Condition #20: 'simpleMessage', 'message', 'condition'
[17:28:40.707]   - Field: 'envir'
[17:28:40.774]  - Condition #21: 'simpleMessage', 'message', 'condition'
[17:28:40.707]   - Field: 'workers'
[17:28:40.774]  - Condition #22: 'simpleMessage', 'message', 'condition'
[17:28:40.707]   - Field: 'packages'
[17:28:40.775]  - Condition #23: 'simpleMessage', 'message', 'condition'
[17:28:40.708]   - Field: 'gc'
[17:28:40.775]  - Condition #24: 'simpleMessage', 'message', 'condition'
[17:28:40.708]   - Field: 'conditions'
[17:28:40.775]  - Condition #25: 'simpleMessage', 'message', 'condition'
[17:28:40.708]   - Field: 'persistent'
[17:28:40.776]  - Condition #26: 'simpleMessage', 'message', 'condition'
[17:28:40.709]   - Field: 'expr'
[17:28:40.776]  - Condition #27: 'simpleMessage', 'message', 'condition'
[17:28:40.709]   - Field: 'uuid'
[17:28:40.776]  - Condition #28: 'simpleMessage', 'message', 'condition'
[17:28:40.709]   - Field: 'seed'
[17:28:40.777]  - Condition #29: 'simpleMessage', 'message', 'condition'
[17:28:40.710]   - Field: 'version'
[17:28:40.777]  - Condition #30: 'simpleMessage', 'message', 'condition'
[17:28:40.710]   - Field: 'result'
[17:28:40.778]  - Condition #31: 'simpleMessage', 'message', 'condition'
[17:28:40.710]   - Field: 'asynchronous'
[17:28:40.778]  - Condition #32: 'simpleMessage', 'message', 'condition'
[17:28:40.711]   - Field: 'calls'
[17:28:40.778]  - Condition #33: 'simpleMessage', 'message', 'condition'
[17:28:40.711]   - Field: 'globals'
[17:28:40.779]  - Condition #34: 'simpleMessage', 'message', 'condition'
[17:28:40.711]   - Field: 'stdout'
[17:28:40.779]  - Condition #35: 'simpleMessage', 'message', 'condition'
[17:28:40.712]   - Field: 'earlySignal'
[17:28:40.780]  - Condition #36: 'simpleMessage', 'message', 'condition'
[17:28:40.712]   - Field: 'lazy'
[17:28:40.780]  - Condition #37: 'simpleMessage', 'message', 'condition'
[17:28:40.712]   - Field: 'state'
[17:28:40.780]  - Condition #38: 'simpleMessage', 'message', 'condition'
[17:28:40.713] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:40.781]  - Condition #39: 'simpleMessage', 'message', 'condition'
[17:28:40.713] - Launch lazy future ...
[17:28:40.781]  - Condition #40: 'simpleMessage', 'message', 'condition'
[17:28:40.714] Packages needed by the future expression (n = 0): <none>
[17:28:40.782]  - Condition #41: 'simpleMessage', 'message', 'condition'
[17:28:40.714] Packages needed by future strategies (n = 0): <none>
[17:28:40.782]  - Condition #42: 'simpleMessage', 'message', 'condition'
[17:28:40.715] {
[17:28:40.715]     {
[17:28:40.715]         {
[17:28:40.715]             ...future.startTime <- base::Sys.time()
[17:28:40.715]             {
[17:28:40.715]                 {
[17:28:40.715]                   {
[17:28:40.715]                     {
[17:28:40.715]                       base::local({
[17:28:40.715]                         has_future <- base::requireNamespace("future", 
[17:28:40.715]                           quietly = TRUE)
[17:28:40.715]                         if (has_future) {
[17:28:40.715]                           ns <- base::getNamespace("future")
[17:28:40.715]                           version <- ns[[".package"]][["version"]]
[17:28:40.715]                           if (is.null(version)) 
[17:28:40.715]                             version <- utils::packageVersion("future")
[17:28:40.715]                         }
[17:28:40.715]                         else {
[17:28:40.715]                           version <- NULL
[17:28:40.715]                         }
[17:28:40.715]                         if (!has_future || version < "1.8.0") {
[17:28:40.715]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:40.715]                             "", base::R.version$version.string), 
[17:28:40.715]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:40.715]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:40.715]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:40.715]                               "release", "version")], collapse = " "), 
[17:28:40.715]                             hostname = base::Sys.info()[["nodename"]])
[17:28:40.715]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:40.715]                             info)
[17:28:40.715]                           info <- base::paste(info, collapse = "; ")
[17:28:40.715]                           if (!has_future) {
[17:28:40.715]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:40.715]                               info)
[17:28:40.715]                           }
[17:28:40.715]                           else {
[17:28:40.715]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:40.715]                               info, version)
[17:28:40.715]                           }
[17:28:40.715]                           base::stop(msg)
[17:28:40.715]                         }
[17:28:40.715]                       })
[17:28:40.715]                     }
[17:28:40.715]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:40.715]                     base::options(mc.cores = 1L)
[17:28:40.715]                   }
[17:28:40.715]                   ...future.strategy.old <- future::plan("list")
[17:28:40.715]                   options(future.plan = NULL)
[17:28:40.715]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.715]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:40.715]                 }
[17:28:40.715]                 ...future.workdir <- getwd()
[17:28:40.715]             }
[17:28:40.715]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:40.715]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:40.715]         }
[17:28:40.715]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:40.715]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:40.715]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:40.715]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:40.715]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:40.715]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:40.715]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:40.715]             base::names(...future.oldOptions))
[17:28:40.715]     }
[17:28:40.715]     if (FALSE) {
[17:28:40.715]     }
[17:28:40.715]     else {
[17:28:40.715]         if (TRUE) {
[17:28:40.715]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:40.715]                 open = "w")
[17:28:40.715]         }
[17:28:40.715]         else {
[17:28:40.715]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:40.715]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:40.715]         }
[17:28:40.715]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:40.715]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:40.715]             base::sink(type = "output", split = FALSE)
[17:28:40.715]             base::close(...future.stdout)
[17:28:40.715]         }, add = TRUE)
[17:28:40.715]     }
[17:28:40.715]     ...future.frame <- base::sys.nframe()
[17:28:40.715]     ...future.conditions <- base::list()
[17:28:40.715]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:40.715]     if (FALSE) {
[17:28:40.715]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:40.715]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:40.715]     }
[17:28:40.715]     ...future.result <- base::tryCatch({
[17:28:40.715]         base::withCallingHandlers({
[17:28:40.715]             ...future.value <- base::withVisible(base::local({
[17:28:40.715]                 ...future.makeSendCondition <- base::local({
[17:28:40.715]                   sendCondition <- NULL
[17:28:40.715]                   function(frame = 1L) {
[17:28:40.715]                     if (is.function(sendCondition)) 
[17:28:40.715]                       return(sendCondition)
[17:28:40.715]                     ns <- getNamespace("parallel")
[17:28:40.715]                     if (exists("sendData", mode = "function", 
[17:28:40.715]                       envir = ns)) {
[17:28:40.715]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:40.715]                         envir = ns)
[17:28:40.715]                       envir <- sys.frame(frame)
[17:28:40.715]                       master <- NULL
[17:28:40.715]                       while (!identical(envir, .GlobalEnv) && 
[17:28:40.715]                         !identical(envir, emptyenv())) {
[17:28:40.715]                         if (exists("master", mode = "list", envir = envir, 
[17:28:40.715]                           inherits = FALSE)) {
[17:28:40.715]                           master <- get("master", mode = "list", 
[17:28:40.715]                             envir = envir, inherits = FALSE)
[17:28:40.715]                           if (inherits(master, c("SOCKnode", 
[17:28:40.715]                             "SOCK0node"))) {
[17:28:40.715]                             sendCondition <<- function(cond) {
[17:28:40.715]                               data <- list(type = "VALUE", value = cond, 
[17:28:40.715]                                 success = TRUE)
[17:28:40.715]                               parallel_sendData(master, data)
[17:28:40.715]                             }
[17:28:40.715]                             return(sendCondition)
[17:28:40.715]                           }
[17:28:40.715]                         }
[17:28:40.715]                         frame <- frame + 1L
[17:28:40.715]                         envir <- sys.frame(frame)
[17:28:40.715]                       }
[17:28:40.715]                     }
[17:28:40.715]                     sendCondition <<- function(cond) NULL
[17:28:40.715]                   }
[17:28:40.715]                 })
[17:28:40.715]                 withCallingHandlers({
[17:28:40.715]                   subset(data, a == 2)
[17:28:40.715]                 }, immediateCondition = function(cond) {
[17:28:40.715]                   sendCondition <- ...future.makeSendCondition()
[17:28:40.715]                   sendCondition(cond)
[17:28:40.715]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.715]                   {
[17:28:40.715]                     inherits <- base::inherits
[17:28:40.715]                     invokeRestart <- base::invokeRestart
[17:28:40.715]                     is.null <- base::is.null
[17:28:40.715]                     muffled <- FALSE
[17:28:40.715]                     if (inherits(cond, "message")) {
[17:28:40.715]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:40.715]                       if (muffled) 
[17:28:40.715]                         invokeRestart("muffleMessage")
[17:28:40.715]                     }
[17:28:40.715]                     else if (inherits(cond, "warning")) {
[17:28:40.715]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:40.715]                       if (muffled) 
[17:28:40.715]                         invokeRestart("muffleWarning")
[17:28:40.715]                     }
[17:28:40.715]                     else if (inherits(cond, "condition")) {
[17:28:40.715]                       if (!is.null(pattern)) {
[17:28:40.715]                         computeRestarts <- base::computeRestarts
[17:28:40.715]                         grepl <- base::grepl
[17:28:40.715]                         restarts <- computeRestarts(cond)
[17:28:40.715]                         for (restart in restarts) {
[17:28:40.715]                           name <- restart$name
[17:28:40.715]                           if (is.null(name)) 
[17:28:40.715]                             next
[17:28:40.715]                           if (!grepl(pattern, name)) 
[17:28:40.715]                             next
[17:28:40.715]                           invokeRestart(restart)
[17:28:40.715]                           muffled <- TRUE
[17:28:40.715]                           break
[17:28:40.715]                         }
[17:28:40.715]                       }
[17:28:40.715]                     }
[17:28:40.715]                     invisible(muffled)
[17:28:40.715]                   }
[17:28:40.715]                   muffleCondition(cond)
[17:28:40.715]                 })
[17:28:40.715]             }))
[17:28:40.715]             future::FutureResult(value = ...future.value$value, 
[17:28:40.715]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.715]                   ...future.rng), globalenv = if (FALSE) 
[17:28:40.715]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:40.715]                     ...future.globalenv.names))
[17:28:40.715]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:40.715]         }, condition = base::local({
[17:28:40.715]             c <- base::c
[17:28:40.715]             inherits <- base::inherits
[17:28:40.715]             invokeRestart <- base::invokeRestart
[17:28:40.715]             length <- base::length
[17:28:40.715]             list <- base::list
[17:28:40.715]             seq.int <- base::seq.int
[17:28:40.715]             signalCondition <- base::signalCondition
[17:28:40.715]             sys.calls <- base::sys.calls
[17:28:40.715]             `[[` <- base::`[[`
[17:28:40.715]             `+` <- base::`+`
[17:28:40.715]             `<<-` <- base::`<<-`
[17:28:40.715]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:40.715]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:40.715]                   3L)]
[17:28:40.715]             }
[17:28:40.715]             function(cond) {
[17:28:40.715]                 is_error <- inherits(cond, "error")
[17:28:40.715]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:40.715]                   NULL)
[17:28:40.715]                 if (is_error) {
[17:28:40.715]                   sessionInformation <- function() {
[17:28:40.715]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:40.715]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:40.715]                       search = base::search(), system = base::Sys.info())
[17:28:40.715]                   }
[17:28:40.715]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.715]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:40.715]                     cond$call), session = sessionInformation(), 
[17:28:40.715]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:40.715]                   signalCondition(cond)
[17:28:40.715]                 }
[17:28:40.715]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:40.715]                 "immediateCondition"))) {
[17:28:40.715]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:40.715]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.715]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:40.715]                   if (TRUE && !signal) {
[17:28:40.715]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.715]                     {
[17:28:40.715]                       inherits <- base::inherits
[17:28:40.715]                       invokeRestart <- base::invokeRestart
[17:28:40.715]                       is.null <- base::is.null
[17:28:40.715]                       muffled <- FALSE
[17:28:40.715]                       if (inherits(cond, "message")) {
[17:28:40.715]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.715]                         if (muffled) 
[17:28:40.715]                           invokeRestart("muffleMessage")
[17:28:40.715]                       }
[17:28:40.715]                       else if (inherits(cond, "warning")) {
[17:28:40.715]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.715]                         if (muffled) 
[17:28:40.715]                           invokeRestart("muffleWarning")
[17:28:40.715]                       }
[17:28:40.715]                       else if (inherits(cond, "condition")) {
[17:28:40.715]                         if (!is.null(pattern)) {
[17:28:40.715]                           computeRestarts <- base::computeRestarts
[17:28:40.715]                           grepl <- base::grepl
[17:28:40.715]                           restarts <- computeRestarts(cond)
[17:28:40.715]                           for (restart in restarts) {
[17:28:40.715]                             name <- restart$name
[17:28:40.715]                             if (is.null(name)) 
[17:28:40.715]                               next
[17:28:40.715]                             if (!grepl(pattern, name)) 
[17:28:40.715]                               next
[17:28:40.715]                             invokeRestart(restart)
[17:28:40.715]                             muffled <- TRUE
[17:28:40.715]                             break
[17:28:40.715]                           }
[17:28:40.715]                         }
[17:28:40.715]                       }
[17:28:40.715]                       invisible(muffled)
[17:28:40.715]                     }
[17:28:40.715]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.715]                   }
[17:28:40.715]                 }
[17:28:40.715]                 else {
[17:28:40.715]                   if (TRUE) {
[17:28:40.715]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.715]                     {
[17:28:40.715]                       inherits <- base::inherits
[17:28:40.715]                       invokeRestart <- base::invokeRestart
[17:28:40.715]                       is.null <- base::is.null
[17:28:40.715]                       muffled <- FALSE
[17:28:40.715]                       if (inherits(cond, "message")) {
[17:28:40.715]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.715]                         if (muffled) 
[17:28:40.715]                           invokeRestart("muffleMessage")
[17:28:40.715]                       }
[17:28:40.715]                       else if (inherits(cond, "warning")) {
[17:28:40.715]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.715]                         if (muffled) 
[17:28:40.715]                           invokeRestart("muffleWarning")
[17:28:40.715]                       }
[17:28:40.715]                       else if (inherits(cond, "condition")) {
[17:28:40.715]                         if (!is.null(pattern)) {
[17:28:40.715]                           computeRestarts <- base::computeRestarts
[17:28:40.715]                           grepl <- base::grepl
[17:28:40.715]                           restarts <- computeRestarts(cond)
[17:28:40.715]                           for (restart in restarts) {
[17:28:40.715]                             name <- restart$name
[17:28:40.715]                             if (is.null(name)) 
[17:28:40.715]                               next
[17:28:40.715]                             if (!grepl(pattern, name)) 
[17:28:40.715]                               next
[17:28:40.715]                             invokeRestart(restart)
[17:28:40.715]                             muffled <- TRUE
[17:28:40.715]                             break
[17:28:40.715]                           }
[17:28:40.715]                         }
[17:28:40.715]                       }
[17:28:40.715]                       invisible(muffled)
[17:28:40.715]                     }
[17:28:40.715]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.715]                   }
[17:28:40.715]                 }
[17:28:40.715]             }
[17:28:40.715]         }))
[17:28:40.715]     }, error = function(ex) {
[17:28:40.715]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:40.715]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.715]                 ...future.rng), started = ...future.startTime, 
[17:28:40.715]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:40.715]             version = "1.8"), class = "FutureResult")
[17:28:40.715]     }, finally = {
[17:28:40.715]         if (!identical(...future.workdir, getwd())) 
[17:28:40.715]             setwd(...future.workdir)
[17:28:40.715]         {
[17:28:40.715]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:40.715]                 ...future.oldOptions$nwarnings <- NULL
[17:28:40.715]             }
[17:28:40.715]             base::options(...future.oldOptions)
[17:28:40.715]             if (.Platform$OS.type == "windows") {
[17:28:40.715]                 old_names <- names(...future.oldEnvVars)
[17:28:40.715]                 envs <- base::Sys.getenv()
[17:28:40.715]                 names <- names(envs)
[17:28:40.715]                 common <- intersect(names, old_names)
[17:28:40.715]                 added <- setdiff(names, old_names)
[17:28:40.715]                 removed <- setdiff(old_names, names)
[17:28:40.715]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:40.715]                   envs[common]]
[17:28:40.715]                 NAMES <- toupper(changed)
[17:28:40.715]                 args <- list()
[17:28:40.715]                 for (kk in seq_along(NAMES)) {
[17:28:40.715]                   name <- changed[[kk]]
[17:28:40.715]                   NAME <- NAMES[[kk]]
[17:28:40.715]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.715]                     next
[17:28:40.715]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.715]                 }
[17:28:40.715]                 NAMES <- toupper(added)
[17:28:40.715]                 for (kk in seq_along(NAMES)) {
[17:28:40.715]                   name <- added[[kk]]
[17:28:40.715]                   NAME <- NAMES[[kk]]
[17:28:40.715]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.715]                     next
[17:28:40.715]                   args[[name]] <- ""
[17:28:40.715]                 }
[17:28:40.715]                 NAMES <- toupper(removed)
[17:28:40.715]                 for (kk in seq_along(NAMES)) {
[17:28:40.715]                   name <- removed[[kk]]
[17:28:40.715]                   NAME <- NAMES[[kk]]
[17:28:40.715]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.715]                     next
[17:28:40.715]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.715]                 }
[17:28:40.715]                 if (length(args) > 0) 
[17:28:40.715]                   base::do.call(base::Sys.setenv, args = args)
[17:28:40.715]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:40.715]             }
[17:28:40.715]             else {
[17:28:40.715]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:40.715]             }
[17:28:40.715]             {
[17:28:40.715]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:40.715]                   0L) {
[17:28:40.715]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:40.715]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:40.715]                   base::options(opts)
[17:28:40.715]                 }
[17:28:40.715]                 {
[17:28:40.715]                   {
[17:28:40.715]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:40.715]                     NULL
[17:28:40.715]                   }
[17:28:40.715]                   options(future.plan = NULL)
[17:28:40.715]                   if (is.na(NA_character_)) 
[17:28:40.715]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.715]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:40.715]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:40.715]                     .init = FALSE)
[17:28:40.715]                 }
[17:28:40.715]             }
[17:28:40.715]         }
[17:28:40.715]     })
[17:28:40.715]     if (TRUE) {
[17:28:40.715]         base::sink(type = "output", split = FALSE)
[17:28:40.715]         if (TRUE) {
[17:28:40.715]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:40.715]         }
[17:28:40.715]         else {
[17:28:40.715]             ...future.result["stdout"] <- base::list(NULL)
[17:28:40.715]         }
[17:28:40.715]         base::close(...future.stdout)
[17:28:40.715]         ...future.stdout <- NULL
[17:28:40.715]     }
[17:28:40.715]     ...future.result$conditions <- ...future.conditions
[17:28:40.715]     ...future.result$finished <- base::Sys.time()
[17:28:40.715]     ...future.result
[17:28:40.715] }
[17:28:40.783]  - Condition #43: 'simpleMessage', 'message', 'condition'
[17:28:40.723] Exporting 1 global objects (639 bytes) to cluster node #1 ...
[17:28:40.783]  - Condition #44: 'simpleMessage', 'message', 'condition'
[17:28:40.724] Exporting 'data' (356 bytes) to cluster node #1 ...
[17:28:40.784]  - Condition #45: 'simpleMessage', 'message', 'condition'
[17:28:40.725] Exporting 'data' (356 bytes) to cluster node #1 ... DONE
[17:28:40.784]  - Condition #46: 'simpleMessage', 'message', 'condition'
[17:28:40.725] Exporting 1 global objects (639 bytes) to cluster node #1 ... DONE
[17:28:40.784]  - Condition #47: 'simpleMessage', 'message', 'condition'
[17:28:40.726] MultisessionFuture started
[17:28:40.785]  - Condition #48: 'simpleMessage', 'message', 'condition'
[17:28:40.726] - Launch lazy future ... done
[17:28:40.785]  - Condition #49: 'simpleMessage', 'message', 'condition'
[17:28:40.727] run() for 'MultisessionFuture' ... done
[17:28:40.786]  - Condition #50: 'simpleMessage', 'message', 'condition'
[17:28:40.727] result() for ClusterFuture ...
[17:28:40.786]  - Condition #51: 'simpleMessage', 'message', 'condition'
[17:28:40.727] receiveMessageFromWorker() for ClusterFuture ...
[17:28:40.786]  - Condition #52: 'simpleMessage', 'message', 'condition'
[17:28:40.728] - Validating connection of MultisessionFuture
[17:28:40.787]  - Condition #53: 'simpleMessage', 'message', 'condition'
[17:28:40.751] - received message: FutureResult
[17:28:40.787]  - Condition #54: 'simpleMessage', 'message', 'condition'
[17:28:40.752] - Received FutureResult
[17:28:40.788]  - Condition #55: 'simpleMessage', 'message', 'condition'
[17:28:40.752] - Erased future from FutureRegistry
[17:28:40.788]  - Condition #56: 'simpleMessage', 'message', 'condition'
[17:28:40.753] result() for ClusterFuture ...
[17:28:40.788]  - Condition #57: 'simpleMessage', 'message', 'condition'
[17:28:40.753] - result already collected: FutureResult
[17:28:40.789]  - Condition #58: 'simpleMessage', 'message', 'condition'
[17:28:40.753] result() for ClusterFuture ... done
[17:28:40.789]  - Condition #59: 'simpleMessage', 'message', 'condition'
[17:28:40.754] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:40.790]  - Condition #60: 'simpleMessage', 'message', 'condition'
[17:28:40.754] result() for ClusterFuture ... done
[17:28:40.790]  - Condition #61: 'simpleMessage', 'message', 'condition'
[17:28:40.754] result() for ClusterFuture ...
[17:28:40.790]  - Condition #62: 'simpleMessage', 'message', 'condition'
[17:28:40.755] - result already collected: FutureResult
[17:28:40.791]  - Condition #63: 'simpleMessage', 'message', 'condition'
[17:28:40.755] result() for ClusterFuture ... done
[17:28:40.791] signalConditions() ... done
- plan(list('sequential', 'multisession')) ... DONE
- plan(list('multisession', 'sequential')) ...
[17:28:40.792] plan(): Setting new future strategy stack:
[17:28:40.792] List of future strategies:
[17:28:40.792] 1. multisession:
[17:28:40.792]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:40.792]    - tweaked: FALSE
[17:28:40.792]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.792] 2. sequential:
[17:28:40.792]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:40.792]    - tweaked: FALSE
[17:28:40.792]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.794] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:40.794] multisession:
[17:28:40.794] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:40.794] - tweaked: FALSE
[17:28:40.794] - call: plan(list(a = strategy1, b = strategy2))
[17:28:40.799] getGlobalsAndPackages() ...
[17:28:40.799] Not searching for globals
[17:28:40.800] - globals: [0] <none>
[17:28:40.800] getGlobalsAndPackages() ... DONE
[17:28:40.816] Packages needed by the future expression (n = 0): <none>
[17:28:40.817] Packages needed by future strategies (n = 1): 'future'
[17:28:40.818] {
[17:28:40.818]     {
[17:28:40.818]         {
[17:28:40.818]             ...future.startTime <- base::Sys.time()
[17:28:40.818]             {
[17:28:40.818]                 {
[17:28:40.818]                   {
[17:28:40.818]                     {
[17:28:40.818]                       {
[17:28:40.818]                         base::local({
[17:28:40.818]                           has_future <- base::requireNamespace("future", 
[17:28:40.818]                             quietly = TRUE)
[17:28:40.818]                           if (has_future) {
[17:28:40.818]                             ns <- base::getNamespace("future")
[17:28:40.818]                             version <- ns[[".package"]][["version"]]
[17:28:40.818]                             if (is.null(version)) 
[17:28:40.818]                               version <- utils::packageVersion("future")
[17:28:40.818]                           }
[17:28:40.818]                           else {
[17:28:40.818]                             version <- NULL
[17:28:40.818]                           }
[17:28:40.818]                           if (!has_future || version < "1.8.0") {
[17:28:40.818]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:40.818]                               "", base::R.version$version.string), 
[17:28:40.818]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:40.818]                                 base::R.version$platform, 8 * 
[17:28:40.818]                                   base::.Machine$sizeof.pointer), 
[17:28:40.818]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:40.818]                                 "release", "version")], collapse = " "), 
[17:28:40.818]                               hostname = base::Sys.info()[["nodename"]])
[17:28:40.818]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:40.818]                               info)
[17:28:40.818]                             info <- base::paste(info, collapse = "; ")
[17:28:40.818]                             if (!has_future) {
[17:28:40.818]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:40.818]                                 info)
[17:28:40.818]                             }
[17:28:40.818]                             else {
[17:28:40.818]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:40.818]                                 info, version)
[17:28:40.818]                             }
[17:28:40.818]                             base::stop(msg)
[17:28:40.818]                           }
[17:28:40.818]                         })
[17:28:40.818]                       }
[17:28:40.818]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:40.818]                       base::options(mc.cores = 1L)
[17:28:40.818]                     }
[17:28:40.818]                     base::local({
[17:28:40.818]                       for (pkg in "future") {
[17:28:40.818]                         base::loadNamespace(pkg)
[17:28:40.818]                         base::library(pkg, character.only = TRUE)
[17:28:40.818]                       }
[17:28:40.818]                     })
[17:28:40.818]                   }
[17:28:40.818]                   ...future.strategy.old <- future::plan("list")
[17:28:40.818]                   options(future.plan = NULL)
[17:28:40.818]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.818]                   future::plan(list(b = function (..., envir = parent.frame()) 
[17:28:40.818]                   {
[17:28:40.818]                     future <- SequentialFuture(..., envir = envir)
[17:28:40.818]                     if (!future$lazy) 
[17:28:40.818]                       future <- run(future)
[17:28:40.818]                     invisible(future)
[17:28:40.818]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:40.818]                 }
[17:28:40.818]                 ...future.workdir <- getwd()
[17:28:40.818]             }
[17:28:40.818]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:40.818]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:40.818]         }
[17:28:40.818]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:40.818]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:40.818]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:40.818]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:40.818]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:40.818]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:40.818]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:40.818]             base::names(...future.oldOptions))
[17:28:40.818]     }
[17:28:40.818]     if (FALSE) {
[17:28:40.818]     }
[17:28:40.818]     else {
[17:28:40.818]         if (TRUE) {
[17:28:40.818]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:40.818]                 open = "w")
[17:28:40.818]         }
[17:28:40.818]         else {
[17:28:40.818]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:40.818]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:40.818]         }
[17:28:40.818]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:40.818]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:40.818]             base::sink(type = "output", split = FALSE)
[17:28:40.818]             base::close(...future.stdout)
[17:28:40.818]         }, add = TRUE)
[17:28:40.818]     }
[17:28:40.818]     ...future.frame <- base::sys.nframe()
[17:28:40.818]     ...future.conditions <- base::list()
[17:28:40.818]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:40.818]     if (FALSE) {
[17:28:40.818]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:40.818]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:40.818]     }
[17:28:40.818]     ...future.result <- base::tryCatch({
[17:28:40.818]         base::withCallingHandlers({
[17:28:40.818]             ...future.value <- base::withVisible(base::local({
[17:28:40.818]                 ...future.makeSendCondition <- base::local({
[17:28:40.818]                   sendCondition <- NULL
[17:28:40.818]                   function(frame = 1L) {
[17:28:40.818]                     if (is.function(sendCondition)) 
[17:28:40.818]                       return(sendCondition)
[17:28:40.818]                     ns <- getNamespace("parallel")
[17:28:40.818]                     if (exists("sendData", mode = "function", 
[17:28:40.818]                       envir = ns)) {
[17:28:40.818]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:40.818]                         envir = ns)
[17:28:40.818]                       envir <- sys.frame(frame)
[17:28:40.818]                       master <- NULL
[17:28:40.818]                       while (!identical(envir, .GlobalEnv) && 
[17:28:40.818]                         !identical(envir, emptyenv())) {
[17:28:40.818]                         if (exists("master", mode = "list", envir = envir, 
[17:28:40.818]                           inherits = FALSE)) {
[17:28:40.818]                           master <- get("master", mode = "list", 
[17:28:40.818]                             envir = envir, inherits = FALSE)
[17:28:40.818]                           if (inherits(master, c("SOCKnode", 
[17:28:40.818]                             "SOCK0node"))) {
[17:28:40.818]                             sendCondition <<- function(cond) {
[17:28:40.818]                               data <- list(type = "VALUE", value = cond, 
[17:28:40.818]                                 success = TRUE)
[17:28:40.818]                               parallel_sendData(master, data)
[17:28:40.818]                             }
[17:28:40.818]                             return(sendCondition)
[17:28:40.818]                           }
[17:28:40.818]                         }
[17:28:40.818]                         frame <- frame + 1L
[17:28:40.818]                         envir <- sys.frame(frame)
[17:28:40.818]                       }
[17:28:40.818]                     }
[17:28:40.818]                     sendCondition <<- function(cond) NULL
[17:28:40.818]                   }
[17:28:40.818]                 })
[17:28:40.818]                 withCallingHandlers({
[17:28:40.818]                   NA
[17:28:40.818]                 }, immediateCondition = function(cond) {
[17:28:40.818]                   sendCondition <- ...future.makeSendCondition()
[17:28:40.818]                   sendCondition(cond)
[17:28:40.818]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.818]                   {
[17:28:40.818]                     inherits <- base::inherits
[17:28:40.818]                     invokeRestart <- base::invokeRestart
[17:28:40.818]                     is.null <- base::is.null
[17:28:40.818]                     muffled <- FALSE
[17:28:40.818]                     if (inherits(cond, "message")) {
[17:28:40.818]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:40.818]                       if (muffled) 
[17:28:40.818]                         invokeRestart("muffleMessage")
[17:28:40.818]                     }
[17:28:40.818]                     else if (inherits(cond, "warning")) {
[17:28:40.818]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:40.818]                       if (muffled) 
[17:28:40.818]                         invokeRestart("muffleWarning")
[17:28:40.818]                     }
[17:28:40.818]                     else if (inherits(cond, "condition")) {
[17:28:40.818]                       if (!is.null(pattern)) {
[17:28:40.818]                         computeRestarts <- base::computeRestarts
[17:28:40.818]                         grepl <- base::grepl
[17:28:40.818]                         restarts <- computeRestarts(cond)
[17:28:40.818]                         for (restart in restarts) {
[17:28:40.818]                           name <- restart$name
[17:28:40.818]                           if (is.null(name)) 
[17:28:40.818]                             next
[17:28:40.818]                           if (!grepl(pattern, name)) 
[17:28:40.818]                             next
[17:28:40.818]                           invokeRestart(restart)
[17:28:40.818]                           muffled <- TRUE
[17:28:40.818]                           break
[17:28:40.818]                         }
[17:28:40.818]                       }
[17:28:40.818]                     }
[17:28:40.818]                     invisible(muffled)
[17:28:40.818]                   }
[17:28:40.818]                   muffleCondition(cond)
[17:28:40.818]                 })
[17:28:40.818]             }))
[17:28:40.818]             future::FutureResult(value = ...future.value$value, 
[17:28:40.818]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.818]                   ...future.rng), globalenv = if (FALSE) 
[17:28:40.818]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:40.818]                     ...future.globalenv.names))
[17:28:40.818]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:40.818]         }, condition = base::local({
[17:28:40.818]             c <- base::c
[17:28:40.818]             inherits <- base::inherits
[17:28:40.818]             invokeRestart <- base::invokeRestart
[17:28:40.818]             length <- base::length
[17:28:40.818]             list <- base::list
[17:28:40.818]             seq.int <- base::seq.int
[17:28:40.818]             signalCondition <- base::signalCondition
[17:28:40.818]             sys.calls <- base::sys.calls
[17:28:40.818]             `[[` <- base::`[[`
[17:28:40.818]             `+` <- base::`+`
[17:28:40.818]             `<<-` <- base::`<<-`
[17:28:40.818]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:40.818]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:40.818]                   3L)]
[17:28:40.818]             }
[17:28:40.818]             function(cond) {
[17:28:40.818]                 is_error <- inherits(cond, "error")
[17:28:40.818]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:40.818]                   NULL)
[17:28:40.818]                 if (is_error) {
[17:28:40.818]                   sessionInformation <- function() {
[17:28:40.818]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:40.818]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:40.818]                       search = base::search(), system = base::Sys.info())
[17:28:40.818]                   }
[17:28:40.818]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.818]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:40.818]                     cond$call), session = sessionInformation(), 
[17:28:40.818]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:40.818]                   signalCondition(cond)
[17:28:40.818]                 }
[17:28:40.818]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:40.818]                 "immediateCondition"))) {
[17:28:40.818]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:40.818]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.818]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:40.818]                   if (TRUE && !signal) {
[17:28:40.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.818]                     {
[17:28:40.818]                       inherits <- base::inherits
[17:28:40.818]                       invokeRestart <- base::invokeRestart
[17:28:40.818]                       is.null <- base::is.null
[17:28:40.818]                       muffled <- FALSE
[17:28:40.818]                       if (inherits(cond, "message")) {
[17:28:40.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.818]                         if (muffled) 
[17:28:40.818]                           invokeRestart("muffleMessage")
[17:28:40.818]                       }
[17:28:40.818]                       else if (inherits(cond, "warning")) {
[17:28:40.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.818]                         if (muffled) 
[17:28:40.818]                           invokeRestart("muffleWarning")
[17:28:40.818]                       }
[17:28:40.818]                       else if (inherits(cond, "condition")) {
[17:28:40.818]                         if (!is.null(pattern)) {
[17:28:40.818]                           computeRestarts <- base::computeRestarts
[17:28:40.818]                           grepl <- base::grepl
[17:28:40.818]                           restarts <- computeRestarts(cond)
[17:28:40.818]                           for (restart in restarts) {
[17:28:40.818]                             name <- restart$name
[17:28:40.818]                             if (is.null(name)) 
[17:28:40.818]                               next
[17:28:40.818]                             if (!grepl(pattern, name)) 
[17:28:40.818]                               next
[17:28:40.818]                             invokeRestart(restart)
[17:28:40.818]                             muffled <- TRUE
[17:28:40.818]                             break
[17:28:40.818]                           }
[17:28:40.818]                         }
[17:28:40.818]                       }
[17:28:40.818]                       invisible(muffled)
[17:28:40.818]                     }
[17:28:40.818]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.818]                   }
[17:28:40.818]                 }
[17:28:40.818]                 else {
[17:28:40.818]                   if (TRUE) {
[17:28:40.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.818]                     {
[17:28:40.818]                       inherits <- base::inherits
[17:28:40.818]                       invokeRestart <- base::invokeRestart
[17:28:40.818]                       is.null <- base::is.null
[17:28:40.818]                       muffled <- FALSE
[17:28:40.818]                       if (inherits(cond, "message")) {
[17:28:40.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.818]                         if (muffled) 
[17:28:40.818]                           invokeRestart("muffleMessage")
[17:28:40.818]                       }
[17:28:40.818]                       else if (inherits(cond, "warning")) {
[17:28:40.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.818]                         if (muffled) 
[17:28:40.818]                           invokeRestart("muffleWarning")
[17:28:40.818]                       }
[17:28:40.818]                       else if (inherits(cond, "condition")) {
[17:28:40.818]                         if (!is.null(pattern)) {
[17:28:40.818]                           computeRestarts <- base::computeRestarts
[17:28:40.818]                           grepl <- base::grepl
[17:28:40.818]                           restarts <- computeRestarts(cond)
[17:28:40.818]                           for (restart in restarts) {
[17:28:40.818]                             name <- restart$name
[17:28:40.818]                             if (is.null(name)) 
[17:28:40.818]                               next
[17:28:40.818]                             if (!grepl(pattern, name)) 
[17:28:40.818]                               next
[17:28:40.818]                             invokeRestart(restart)
[17:28:40.818]                             muffled <- TRUE
[17:28:40.818]                             break
[17:28:40.818]                           }
[17:28:40.818]                         }
[17:28:40.818]                       }
[17:28:40.818]                       invisible(muffled)
[17:28:40.818]                     }
[17:28:40.818]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.818]                   }
[17:28:40.818]                 }
[17:28:40.818]             }
[17:28:40.818]         }))
[17:28:40.818]     }, error = function(ex) {
[17:28:40.818]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:40.818]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.818]                 ...future.rng), started = ...future.startTime, 
[17:28:40.818]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:40.818]             version = "1.8"), class = "FutureResult")
[17:28:40.818]     }, finally = {
[17:28:40.818]         if (!identical(...future.workdir, getwd())) 
[17:28:40.818]             setwd(...future.workdir)
[17:28:40.818]         {
[17:28:40.818]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:40.818]                 ...future.oldOptions$nwarnings <- NULL
[17:28:40.818]             }
[17:28:40.818]             base::options(...future.oldOptions)
[17:28:40.818]             if (.Platform$OS.type == "windows") {
[17:28:40.818]                 old_names <- names(...future.oldEnvVars)
[17:28:40.818]                 envs <- base::Sys.getenv()
[17:28:40.818]                 names <- names(envs)
[17:28:40.818]                 common <- intersect(names, old_names)
[17:28:40.818]                 added <- setdiff(names, old_names)
[17:28:40.818]                 removed <- setdiff(old_names, names)
[17:28:40.818]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:40.818]                   envs[common]]
[17:28:40.818]                 NAMES <- toupper(changed)
[17:28:40.818]                 args <- list()
[17:28:40.818]                 for (kk in seq_along(NAMES)) {
[17:28:40.818]                   name <- changed[[kk]]
[17:28:40.818]                   NAME <- NAMES[[kk]]
[17:28:40.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.818]                     next
[17:28:40.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.818]                 }
[17:28:40.818]                 NAMES <- toupper(added)
[17:28:40.818]                 for (kk in seq_along(NAMES)) {
[17:28:40.818]                   name <- added[[kk]]
[17:28:40.818]                   NAME <- NAMES[[kk]]
[17:28:40.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.818]                     next
[17:28:40.818]                   args[[name]] <- ""
[17:28:40.818]                 }
[17:28:40.818]                 NAMES <- toupper(removed)
[17:28:40.818]                 for (kk in seq_along(NAMES)) {
[17:28:40.818]                   name <- removed[[kk]]
[17:28:40.818]                   NAME <- NAMES[[kk]]
[17:28:40.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.818]                     next
[17:28:40.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.818]                 }
[17:28:40.818]                 if (length(args) > 0) 
[17:28:40.818]                   base::do.call(base::Sys.setenv, args = args)
[17:28:40.818]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:40.818]             }
[17:28:40.818]             else {
[17:28:40.818]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:40.818]             }
[17:28:40.818]             {
[17:28:40.818]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:40.818]                   0L) {
[17:28:40.818]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:40.818]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:40.818]                   base::options(opts)
[17:28:40.818]                 }
[17:28:40.818]                 {
[17:28:40.818]                   {
[17:28:40.818]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:40.818]                     NULL
[17:28:40.818]                   }
[17:28:40.818]                   options(future.plan = NULL)
[17:28:40.818]                   if (is.na(NA_character_)) 
[17:28:40.818]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.818]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:40.818]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:40.818]                     .init = FALSE)
[17:28:40.818]                 }
[17:28:40.818]             }
[17:28:40.818]         }
[17:28:40.818]     })
[17:28:40.818]     if (TRUE) {
[17:28:40.818]         base::sink(type = "output", split = FALSE)
[17:28:40.818]         if (TRUE) {
[17:28:40.818]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:40.818]         }
[17:28:40.818]         else {
[17:28:40.818]             ...future.result["stdout"] <- base::list(NULL)
[17:28:40.818]         }
[17:28:40.818]         base::close(...future.stdout)
[17:28:40.818]         ...future.stdout <- NULL
[17:28:40.818]     }
[17:28:40.818]     ...future.result$conditions <- ...future.conditions
[17:28:40.818]     ...future.result$finished <- base::Sys.time()
[17:28:40.818]     ...future.result
[17:28:40.818] }
[17:28:40.827] MultisessionFuture started
[17:28:40.828] result() for ClusterFuture ...
[17:28:40.828] receiveMessageFromWorker() for ClusterFuture ...
[17:28:40.828] - Validating connection of MultisessionFuture
[17:28:40.870] - received message: FutureResult
[17:28:40.871] - Received FutureResult
[17:28:40.871] - Erased future from FutureRegistry
[17:28:40.872] result() for ClusterFuture ...
[17:28:40.872] - result already collected: FutureResult
[17:28:40.872] result() for ClusterFuture ... done
[17:28:40.873] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:40.873] result() for ClusterFuture ... done
[17:28:40.873] result() for ClusterFuture ...
[17:28:40.873] - result already collected: FutureResult
[17:28:40.874] result() for ClusterFuture ... done
[17:28:40.874] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:40.878] plan(): nbrOfWorkers() = 2
[17:28:40.879] getGlobalsAndPackages() ...
[17:28:40.879] Searching for globals...
[17:28:40.911] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[17:28:40.912] Searching for globals ... DONE
[17:28:40.912] Resolving globals: FALSE
[17:28:40.914] The total size of the 2 globals is 7.46 KiB (7637 bytes)
[17:28:40.915] The total size of the 2 globals exported for future expression ('{; a <- 1L; plan_a <- unclass(future::plan("list")); nested_a <- nested[-1]; stopifnot(length(nested_a) == 1L, length(plan_a) == 1L, inherits(plan_a[[1]],; "future"), inherits(future::plan("next"), strategy2)); ...; }; y; }') is 7.46 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (7.41 KiB of class 'list') and 'strategy2' (49 bytes of class 'character')
[17:28:40.915] - globals: [2] 'nested', 'strategy2'
[17:28:40.915] - packages: [1] 'future'
[17:28:40.916] getGlobalsAndPackages() ... DONE
[17:28:40.916] run() for 'Future' ...
[17:28:40.916] - state: 'created'
[17:28:40.917] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:40.937] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:40.938] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:40.938]   - Field: 'node'
[17:28:40.938]   - Field: 'label'
[17:28:40.939]   - Field: 'local'
[17:28:40.939]   - Field: 'owner'
[17:28:40.939]   - Field: 'envir'
[17:28:40.940]   - Field: 'workers'
[17:28:40.940]   - Field: 'packages'
[17:28:40.940]   - Field: 'gc'
[17:28:40.940]   - Field: 'conditions'
[17:28:40.941]   - Field: 'persistent'
[17:28:40.941]   - Field: 'expr'
[17:28:40.941]   - Field: 'uuid'
[17:28:40.941]   - Field: 'seed'
[17:28:40.941]   - Field: 'version'
[17:28:40.942]   - Field: 'result'
[17:28:40.942]   - Field: 'asynchronous'
[17:28:40.942]   - Field: 'calls'
[17:28:40.942]   - Field: 'globals'
[17:28:40.942]   - Field: 'stdout'
[17:28:40.942]   - Field: 'earlySignal'
[17:28:40.943]   - Field: 'lazy'
[17:28:40.943]   - Field: 'state'
[17:28:40.943] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:40.943] - Launch lazy future ...
[17:28:40.944] Packages needed by the future expression (n = 1): 'future'
[17:28:40.944] Packages needed by future strategies (n = 1): 'future'
[17:28:40.945] {
[17:28:40.945]     {
[17:28:40.945]         {
[17:28:40.945]             ...future.startTime <- base::Sys.time()
[17:28:40.945]             {
[17:28:40.945]                 {
[17:28:40.945]                   {
[17:28:40.945]                     {
[17:28:40.945]                       {
[17:28:40.945]                         base::local({
[17:28:40.945]                           has_future <- base::requireNamespace("future", 
[17:28:40.945]                             quietly = TRUE)
[17:28:40.945]                           if (has_future) {
[17:28:40.945]                             ns <- base::getNamespace("future")
[17:28:40.945]                             version <- ns[[".package"]][["version"]]
[17:28:40.945]                             if (is.null(version)) 
[17:28:40.945]                               version <- utils::packageVersion("future")
[17:28:40.945]                           }
[17:28:40.945]                           else {
[17:28:40.945]                             version <- NULL
[17:28:40.945]                           }
[17:28:40.945]                           if (!has_future || version < "1.8.0") {
[17:28:40.945]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:40.945]                               "", base::R.version$version.string), 
[17:28:40.945]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:40.945]                                 base::R.version$platform, 8 * 
[17:28:40.945]                                   base::.Machine$sizeof.pointer), 
[17:28:40.945]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:40.945]                                 "release", "version")], collapse = " "), 
[17:28:40.945]                               hostname = base::Sys.info()[["nodename"]])
[17:28:40.945]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:40.945]                               info)
[17:28:40.945]                             info <- base::paste(info, collapse = "; ")
[17:28:40.945]                             if (!has_future) {
[17:28:40.945]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:40.945]                                 info)
[17:28:40.945]                             }
[17:28:40.945]                             else {
[17:28:40.945]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:40.945]                                 info, version)
[17:28:40.945]                             }
[17:28:40.945]                             base::stop(msg)
[17:28:40.945]                           }
[17:28:40.945]                         })
[17:28:40.945]                       }
[17:28:40.945]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:40.945]                       base::options(mc.cores = 1L)
[17:28:40.945]                     }
[17:28:40.945]                     base::local({
[17:28:40.945]                       for (pkg in "future") {
[17:28:40.945]                         base::loadNamespace(pkg)
[17:28:40.945]                         base::library(pkg, character.only = TRUE)
[17:28:40.945]                       }
[17:28:40.945]                     })
[17:28:40.945]                   }
[17:28:40.945]                   ...future.strategy.old <- future::plan("list")
[17:28:40.945]                   options(future.plan = NULL)
[17:28:40.945]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.945]                   future::plan(list(b = function (..., envir = parent.frame()) 
[17:28:40.945]                   {
[17:28:40.945]                     future <- SequentialFuture(..., envir = envir)
[17:28:40.945]                     if (!future$lazy) 
[17:28:40.945]                       future <- run(future)
[17:28:40.945]                     invisible(future)
[17:28:40.945]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:40.945]                 }
[17:28:40.945]                 ...future.workdir <- getwd()
[17:28:40.945]             }
[17:28:40.945]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:40.945]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:40.945]         }
[17:28:40.945]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:40.945]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:40.945]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:40.945]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:40.945]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:40.945]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:40.945]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:40.945]             base::names(...future.oldOptions))
[17:28:40.945]     }
[17:28:40.945]     if (FALSE) {
[17:28:40.945]     }
[17:28:40.945]     else {
[17:28:40.945]         if (TRUE) {
[17:28:40.945]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:40.945]                 open = "w")
[17:28:40.945]         }
[17:28:40.945]         else {
[17:28:40.945]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:40.945]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:40.945]         }
[17:28:40.945]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:40.945]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:40.945]             base::sink(type = "output", split = FALSE)
[17:28:40.945]             base::close(...future.stdout)
[17:28:40.945]         }, add = TRUE)
[17:28:40.945]     }
[17:28:40.945]     ...future.frame <- base::sys.nframe()
[17:28:40.945]     ...future.conditions <- base::list()
[17:28:40.945]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:40.945]     if (FALSE) {
[17:28:40.945]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:40.945]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:40.945]     }
[17:28:40.945]     ...future.result <- base::tryCatch({
[17:28:40.945]         base::withCallingHandlers({
[17:28:40.945]             ...future.value <- base::withVisible(base::local({
[17:28:40.945]                 ...future.makeSendCondition <- base::local({
[17:28:40.945]                   sendCondition <- NULL
[17:28:40.945]                   function(frame = 1L) {
[17:28:40.945]                     if (is.function(sendCondition)) 
[17:28:40.945]                       return(sendCondition)
[17:28:40.945]                     ns <- getNamespace("parallel")
[17:28:40.945]                     if (exists("sendData", mode = "function", 
[17:28:40.945]                       envir = ns)) {
[17:28:40.945]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:40.945]                         envir = ns)
[17:28:40.945]                       envir <- sys.frame(frame)
[17:28:40.945]                       master <- NULL
[17:28:40.945]                       while (!identical(envir, .GlobalEnv) && 
[17:28:40.945]                         !identical(envir, emptyenv())) {
[17:28:40.945]                         if (exists("master", mode = "list", envir = envir, 
[17:28:40.945]                           inherits = FALSE)) {
[17:28:40.945]                           master <- get("master", mode = "list", 
[17:28:40.945]                             envir = envir, inherits = FALSE)
[17:28:40.945]                           if (inherits(master, c("SOCKnode", 
[17:28:40.945]                             "SOCK0node"))) {
[17:28:40.945]                             sendCondition <<- function(cond) {
[17:28:40.945]                               data <- list(type = "VALUE", value = cond, 
[17:28:40.945]                                 success = TRUE)
[17:28:40.945]                               parallel_sendData(master, data)
[17:28:40.945]                             }
[17:28:40.945]                             return(sendCondition)
[17:28:40.945]                           }
[17:28:40.945]                         }
[17:28:40.945]                         frame <- frame + 1L
[17:28:40.945]                         envir <- sys.frame(frame)
[17:28:40.945]                       }
[17:28:40.945]                     }
[17:28:40.945]                     sendCondition <<- function(cond) NULL
[17:28:40.945]                   }
[17:28:40.945]                 })
[17:28:40.945]                 withCallingHandlers({
[17:28:40.945]                   {
[17:28:40.945]                     a <- 1L
[17:28:40.945]                     plan_a <- unclass(future::plan("list"))
[17:28:40.945]                     nested_a <- nested[-1]
[17:28:40.945]                     stopifnot(length(nested_a) == 1L, length(plan_a) == 
[17:28:40.945]                       1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[17:28:40.945]                       strategy2))
[17:28:40.945]                     for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[17:28:40.945]                       "init") <- NULL
[17:28:40.945]                     for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[17:28:40.945]                       "init") <- NULL
[17:28:40.945]                     stopifnot(all.equal(plan_a, nested_a))
[17:28:40.945]                     y %<-% {
[17:28:40.945]                       b <- 2L
[17:28:40.945]                       plan_b <- future::plan("list")
[17:28:40.945]                       nested_b <- nested_a[-1]
[17:28:40.945]                       stopifnot(length(nested_b) == 0L, length(plan_b) == 
[17:28:40.945]                         1L, inherits(plan_b[[1]], "future"), 
[17:28:40.945]                         inherits(future::plan("next"), "sequential"))
[17:28:40.945]                       list(a = a, nested_a = nested_a, plan_a = plan_a, 
[17:28:40.945]                         b = b, nested_b = nested_b, plan_b = plan_b)
[17:28:40.945]                     }
[17:28:40.945]                     y
[17:28:40.945]                   }
[17:28:40.945]                 }, immediateCondition = function(cond) {
[17:28:40.945]                   sendCondition <- ...future.makeSendCondition()
[17:28:40.945]                   sendCondition(cond)
[17:28:40.945]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.945]                   {
[17:28:40.945]                     inherits <- base::inherits
[17:28:40.945]                     invokeRestart <- base::invokeRestart
[17:28:40.945]                     is.null <- base::is.null
[17:28:40.945]                     muffled <- FALSE
[17:28:40.945]                     if (inherits(cond, "message")) {
[17:28:40.945]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:40.945]                       if (muffled) 
[17:28:40.945]                         invokeRestart("muffleMessage")
[17:28:40.945]                     }
[17:28:40.945]                     else if (inherits(cond, "warning")) {
[17:28:40.945]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:40.945]                       if (muffled) 
[17:28:40.945]                         invokeRestart("muffleWarning")
[17:28:40.945]                     }
[17:28:40.945]                     else if (inherits(cond, "condition")) {
[17:28:40.945]                       if (!is.null(pattern)) {
[17:28:40.945]                         computeRestarts <- base::computeRestarts
[17:28:40.945]                         grepl <- base::grepl
[17:28:40.945]                         restarts <- computeRestarts(cond)
[17:28:40.945]                         for (restart in restarts) {
[17:28:40.945]                           name <- restart$name
[17:28:40.945]                           if (is.null(name)) 
[17:28:40.945]                             next
[17:28:40.945]                           if (!grepl(pattern, name)) 
[17:28:40.945]                             next
[17:28:40.945]                           invokeRestart(restart)
[17:28:40.945]                           muffled <- TRUE
[17:28:40.945]                           break
[17:28:40.945]                         }
[17:28:40.945]                       }
[17:28:40.945]                     }
[17:28:40.945]                     invisible(muffled)
[17:28:40.945]                   }
[17:28:40.945]                   muffleCondition(cond)
[17:28:40.945]                 })
[17:28:40.945]             }))
[17:28:40.945]             future::FutureResult(value = ...future.value$value, 
[17:28:40.945]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.945]                   ...future.rng), globalenv = if (FALSE) 
[17:28:40.945]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:40.945]                     ...future.globalenv.names))
[17:28:40.945]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:40.945]         }, condition = base::local({
[17:28:40.945]             c <- base::c
[17:28:40.945]             inherits <- base::inherits
[17:28:40.945]             invokeRestart <- base::invokeRestart
[17:28:40.945]             length <- base::length
[17:28:40.945]             list <- base::list
[17:28:40.945]             seq.int <- base::seq.int
[17:28:40.945]             signalCondition <- base::signalCondition
[17:28:40.945]             sys.calls <- base::sys.calls
[17:28:40.945]             `[[` <- base::`[[`
[17:28:40.945]             `+` <- base::`+`
[17:28:40.945]             `<<-` <- base::`<<-`
[17:28:40.945]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:40.945]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:40.945]                   3L)]
[17:28:40.945]             }
[17:28:40.945]             function(cond) {
[17:28:40.945]                 is_error <- inherits(cond, "error")
[17:28:40.945]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:40.945]                   NULL)
[17:28:40.945]                 if (is_error) {
[17:28:40.945]                   sessionInformation <- function() {
[17:28:40.945]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:40.945]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:40.945]                       search = base::search(), system = base::Sys.info())
[17:28:40.945]                   }
[17:28:40.945]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.945]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:40.945]                     cond$call), session = sessionInformation(), 
[17:28:40.945]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:40.945]                   signalCondition(cond)
[17:28:40.945]                 }
[17:28:40.945]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:40.945]                 "immediateCondition"))) {
[17:28:40.945]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:40.945]                   ...future.conditions[[length(...future.conditions) + 
[17:28:40.945]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:40.945]                   if (TRUE && !signal) {
[17:28:40.945]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.945]                     {
[17:28:40.945]                       inherits <- base::inherits
[17:28:40.945]                       invokeRestart <- base::invokeRestart
[17:28:40.945]                       is.null <- base::is.null
[17:28:40.945]                       muffled <- FALSE
[17:28:40.945]                       if (inherits(cond, "message")) {
[17:28:40.945]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.945]                         if (muffled) 
[17:28:40.945]                           invokeRestart("muffleMessage")
[17:28:40.945]                       }
[17:28:40.945]                       else if (inherits(cond, "warning")) {
[17:28:40.945]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.945]                         if (muffled) 
[17:28:40.945]                           invokeRestart("muffleWarning")
[17:28:40.945]                       }
[17:28:40.945]                       else if (inherits(cond, "condition")) {
[17:28:40.945]                         if (!is.null(pattern)) {
[17:28:40.945]                           computeRestarts <- base::computeRestarts
[17:28:40.945]                           grepl <- base::grepl
[17:28:40.945]                           restarts <- computeRestarts(cond)
[17:28:40.945]                           for (restart in restarts) {
[17:28:40.945]                             name <- restart$name
[17:28:40.945]                             if (is.null(name)) 
[17:28:40.945]                               next
[17:28:40.945]                             if (!grepl(pattern, name)) 
[17:28:40.945]                               next
[17:28:40.945]                             invokeRestart(restart)
[17:28:40.945]                             muffled <- TRUE
[17:28:40.945]                             break
[17:28:40.945]                           }
[17:28:40.945]                         }
[17:28:40.945]                       }
[17:28:40.945]                       invisible(muffled)
[17:28:40.945]                     }
[17:28:40.945]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.945]                   }
[17:28:40.945]                 }
[17:28:40.945]                 else {
[17:28:40.945]                   if (TRUE) {
[17:28:40.945]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:40.945]                     {
[17:28:40.945]                       inherits <- base::inherits
[17:28:40.945]                       invokeRestart <- base::invokeRestart
[17:28:40.945]                       is.null <- base::is.null
[17:28:40.945]                       muffled <- FALSE
[17:28:40.945]                       if (inherits(cond, "message")) {
[17:28:40.945]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:40.945]                         if (muffled) 
[17:28:40.945]                           invokeRestart("muffleMessage")
[17:28:40.945]                       }
[17:28:40.945]                       else if (inherits(cond, "warning")) {
[17:28:40.945]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:40.945]                         if (muffled) 
[17:28:40.945]                           invokeRestart("muffleWarning")
[17:28:40.945]                       }
[17:28:40.945]                       else if (inherits(cond, "condition")) {
[17:28:40.945]                         if (!is.null(pattern)) {
[17:28:40.945]                           computeRestarts <- base::computeRestarts
[17:28:40.945]                           grepl <- base::grepl
[17:28:40.945]                           restarts <- computeRestarts(cond)
[17:28:40.945]                           for (restart in restarts) {
[17:28:40.945]                             name <- restart$name
[17:28:40.945]                             if (is.null(name)) 
[17:28:40.945]                               next
[17:28:40.945]                             if (!grepl(pattern, name)) 
[17:28:40.945]                               next
[17:28:40.945]                             invokeRestart(restart)
[17:28:40.945]                             muffled <- TRUE
[17:28:40.945]                             break
[17:28:40.945]                           }
[17:28:40.945]                         }
[17:28:40.945]                       }
[17:28:40.945]                       invisible(muffled)
[17:28:40.945]                     }
[17:28:40.945]                     muffleCondition(cond, pattern = "^muffle")
[17:28:40.945]                   }
[17:28:40.945]                 }
[17:28:40.945]             }
[17:28:40.945]         }))
[17:28:40.945]     }, error = function(ex) {
[17:28:40.945]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:40.945]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:40.945]                 ...future.rng), started = ...future.startTime, 
[17:28:40.945]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:40.945]             version = "1.8"), class = "FutureResult")
[17:28:40.945]     }, finally = {
[17:28:40.945]         if (!identical(...future.workdir, getwd())) 
[17:28:40.945]             setwd(...future.workdir)
[17:28:40.945]         {
[17:28:40.945]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:40.945]                 ...future.oldOptions$nwarnings <- NULL
[17:28:40.945]             }
[17:28:40.945]             base::options(...future.oldOptions)
[17:28:40.945]             if (.Platform$OS.type == "windows") {
[17:28:40.945]                 old_names <- names(...future.oldEnvVars)
[17:28:40.945]                 envs <- base::Sys.getenv()
[17:28:40.945]                 names <- names(envs)
[17:28:40.945]                 common <- intersect(names, old_names)
[17:28:40.945]                 added <- setdiff(names, old_names)
[17:28:40.945]                 removed <- setdiff(old_names, names)
[17:28:40.945]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:40.945]                   envs[common]]
[17:28:40.945]                 NAMES <- toupper(changed)
[17:28:40.945]                 args <- list()
[17:28:40.945]                 for (kk in seq_along(NAMES)) {
[17:28:40.945]                   name <- changed[[kk]]
[17:28:40.945]                   NAME <- NAMES[[kk]]
[17:28:40.945]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.945]                     next
[17:28:40.945]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.945]                 }
[17:28:40.945]                 NAMES <- toupper(added)
[17:28:40.945]                 for (kk in seq_along(NAMES)) {
[17:28:40.945]                   name <- added[[kk]]
[17:28:40.945]                   NAME <- NAMES[[kk]]
[17:28:40.945]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.945]                     next
[17:28:40.945]                   args[[name]] <- ""
[17:28:40.945]                 }
[17:28:40.945]                 NAMES <- toupper(removed)
[17:28:40.945]                 for (kk in seq_along(NAMES)) {
[17:28:40.945]                   name <- removed[[kk]]
[17:28:40.945]                   NAME <- NAMES[[kk]]
[17:28:40.945]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:40.945]                     next
[17:28:40.945]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:40.945]                 }
[17:28:40.945]                 if (length(args) > 0) 
[17:28:40.945]                   base::do.call(base::Sys.setenv, args = args)
[17:28:40.945]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:40.945]             }
[17:28:40.945]             else {
[17:28:40.945]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:40.945]             }
[17:28:40.945]             {
[17:28:40.945]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:40.945]                   0L) {
[17:28:40.945]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:40.945]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:40.945]                   base::options(opts)
[17:28:40.945]                 }
[17:28:40.945]                 {
[17:28:40.945]                   {
[17:28:40.945]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:40.945]                     NULL
[17:28:40.945]                   }
[17:28:40.945]                   options(future.plan = NULL)
[17:28:40.945]                   if (is.na(NA_character_)) 
[17:28:40.945]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:40.945]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:40.945]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:40.945]                     .init = FALSE)
[17:28:40.945]                 }
[17:28:40.945]             }
[17:28:40.945]         }
[17:28:40.945]     })
[17:28:40.945]     if (TRUE) {
[17:28:40.945]         base::sink(type = "output", split = FALSE)
[17:28:40.945]         if (TRUE) {
[17:28:40.945]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:40.945]         }
[17:28:40.945]         else {
[17:28:40.945]             ...future.result["stdout"] <- base::list(NULL)
[17:28:40.945]         }
[17:28:40.945]         base::close(...future.stdout)
[17:28:40.945]         ...future.stdout <- NULL
[17:28:40.945]     }
[17:28:40.945]     ...future.result$conditions <- ...future.conditions
[17:28:40.945]     ...future.result$finished <- base::Sys.time()
[17:28:40.945]     ...future.result
[17:28:40.945] }
[17:28:40.950] Exporting 2 global objects (7.75 KiB) to cluster node #1 ...
[17:28:40.951] Exporting 'nested' (7.41 KiB) to cluster node #1 ...
[17:28:40.952] Exporting 'nested' (7.41 KiB) to cluster node #1 ... DONE
[17:28:40.953] Exporting 'strategy2' (49 bytes) to cluster node #1 ...
[17:28:40.953] Exporting 'strategy2' (49 bytes) to cluster node #1 ... DONE
[17:28:40.954] Exporting 2 global objects (7.75 KiB) to cluster node #1 ... DONE
[17:28:40.955] MultisessionFuture started
[17:28:40.955] - Launch lazy future ... done
[17:28:40.956] run() for 'MultisessionFuture' ... done
[17:28:40.956] result() for ClusterFuture ...
[17:28:40.957] receiveMessageFromWorker() for ClusterFuture ...
[17:28:40.957] - Validating connection of MultisessionFuture
[17:28:41.022] - received message: FutureResult
[17:28:41.022] - Received FutureResult
[17:28:41.022] - Erased future from FutureRegistry
[17:28:41.023] result() for ClusterFuture ...
[17:28:41.023] - result already collected: FutureResult
[17:28:41.023] result() for ClusterFuture ... done
[17:28:41.024] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:41.024] result() for ClusterFuture ... done
[17:28:41.024] result() for ClusterFuture ...
[17:28:41.025] - result already collected: FutureResult
[17:28:41.025] result() for ClusterFuture ... done
List of 6
 $ a       : int 1
 $ nested_a:List of 1
  ..$ b:function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ plan_a  :List of 1
  ..$ b:function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ b       : int 2
 $ nested_b: Named list()
 $ plan_b  :List of 1
  ..$ :function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[17:28:41.032] getGlobalsAndPackages() ...
[17:28:41.032] Searching for globals...
[17:28:41.034] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[17:28:41.034] Searching for globals ... DONE
[17:28:41.035] Resolving globals: FALSE
[17:28:41.036] The total size of the 1 globals is 356 bytes (356 bytes)
[17:28:41.036] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 356 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (356 bytes of class 'list')
[17:28:41.037] - globals: [1] 'data'
[17:28:41.037] - packages: [1] 'future'
[17:28:41.038] getGlobalsAndPackages() ... DONE
[17:28:41.038] run() for 'Future' ...
[17:28:41.039] - state: 'created'
[17:28:41.039] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:41.057] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:41.058] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:41.058]   - Field: 'node'
[17:28:41.058]   - Field: 'label'
[17:28:41.058]   - Field: 'local'
[17:28:41.058]   - Field: 'owner'
[17:28:41.059]   - Field: 'envir'
[17:28:41.059]   - Field: 'workers'
[17:28:41.059]   - Field: 'packages'
[17:28:41.059]   - Field: 'gc'
[17:28:41.059]   - Field: 'conditions'
[17:28:41.060]   - Field: 'persistent'
[17:28:41.060]   - Field: 'expr'
[17:28:41.060]   - Field: 'uuid'
[17:28:41.060]   - Field: 'seed'
[17:28:41.061]   - Field: 'version'
[17:28:41.061]   - Field: 'result'
[17:28:41.061]   - Field: 'asynchronous'
[17:28:41.061]   - Field: 'calls'
[17:28:41.062]   - Field: 'globals'
[17:28:41.062]   - Field: 'stdout'
[17:28:41.062]   - Field: 'earlySignal'
[17:28:41.062]   - Field: 'lazy'
[17:28:41.063]   - Field: 'state'
[17:28:41.063] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:41.063] - Launch lazy future ...
[17:28:41.063] Packages needed by the future expression (n = 1): 'future'
[17:28:41.064] Packages needed by future strategies (n = 1): 'future'
[17:28:41.064] {
[17:28:41.064]     {
[17:28:41.064]         {
[17:28:41.064]             ...future.startTime <- base::Sys.time()
[17:28:41.064]             {
[17:28:41.064]                 {
[17:28:41.064]                   {
[17:28:41.064]                     {
[17:28:41.064]                       {
[17:28:41.064]                         base::local({
[17:28:41.064]                           has_future <- base::requireNamespace("future", 
[17:28:41.064]                             quietly = TRUE)
[17:28:41.064]                           if (has_future) {
[17:28:41.064]                             ns <- base::getNamespace("future")
[17:28:41.064]                             version <- ns[[".package"]][["version"]]
[17:28:41.064]                             if (is.null(version)) 
[17:28:41.064]                               version <- utils::packageVersion("future")
[17:28:41.064]                           }
[17:28:41.064]                           else {
[17:28:41.064]                             version <- NULL
[17:28:41.064]                           }
[17:28:41.064]                           if (!has_future || version < "1.8.0") {
[17:28:41.064]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:41.064]                               "", base::R.version$version.string), 
[17:28:41.064]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:41.064]                                 base::R.version$platform, 8 * 
[17:28:41.064]                                   base::.Machine$sizeof.pointer), 
[17:28:41.064]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:41.064]                                 "release", "version")], collapse = " "), 
[17:28:41.064]                               hostname = base::Sys.info()[["nodename"]])
[17:28:41.064]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:41.064]                               info)
[17:28:41.064]                             info <- base::paste(info, collapse = "; ")
[17:28:41.064]                             if (!has_future) {
[17:28:41.064]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:41.064]                                 info)
[17:28:41.064]                             }
[17:28:41.064]                             else {
[17:28:41.064]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:41.064]                                 info, version)
[17:28:41.064]                             }
[17:28:41.064]                             base::stop(msg)
[17:28:41.064]                           }
[17:28:41.064]                         })
[17:28:41.064]                       }
[17:28:41.064]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:41.064]                       base::options(mc.cores = 1L)
[17:28:41.064]                     }
[17:28:41.064]                     base::local({
[17:28:41.064]                       for (pkg in "future") {
[17:28:41.064]                         base::loadNamespace(pkg)
[17:28:41.064]                         base::library(pkg, character.only = TRUE)
[17:28:41.064]                       }
[17:28:41.064]                     })
[17:28:41.064]                   }
[17:28:41.064]                   ...future.strategy.old <- future::plan("list")
[17:28:41.064]                   options(future.plan = NULL)
[17:28:41.064]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.064]                   future::plan(list(b = function (..., envir = parent.frame()) 
[17:28:41.064]                   {
[17:28:41.064]                     future <- SequentialFuture(..., envir = envir)
[17:28:41.064]                     if (!future$lazy) 
[17:28:41.064]                       future <- run(future)
[17:28:41.064]                     invisible(future)
[17:28:41.064]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:41.064]                 }
[17:28:41.064]                 ...future.workdir <- getwd()
[17:28:41.064]             }
[17:28:41.064]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:41.064]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:41.064]         }
[17:28:41.064]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:41.064]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:41.064]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:41.064]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:41.064]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:41.064]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:41.064]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:41.064]             base::names(...future.oldOptions))
[17:28:41.064]     }
[17:28:41.064]     if (FALSE) {
[17:28:41.064]     }
[17:28:41.064]     else {
[17:28:41.064]         if (TRUE) {
[17:28:41.064]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:41.064]                 open = "w")
[17:28:41.064]         }
[17:28:41.064]         else {
[17:28:41.064]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:41.064]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:41.064]         }
[17:28:41.064]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:41.064]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:41.064]             base::sink(type = "output", split = FALSE)
[17:28:41.064]             base::close(...future.stdout)
[17:28:41.064]         }, add = TRUE)
[17:28:41.064]     }
[17:28:41.064]     ...future.frame <- base::sys.nframe()
[17:28:41.064]     ...future.conditions <- base::list()
[17:28:41.064]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:41.064]     if (FALSE) {
[17:28:41.064]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:41.064]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:41.064]     }
[17:28:41.064]     ...future.result <- base::tryCatch({
[17:28:41.064]         base::withCallingHandlers({
[17:28:41.064]             ...future.value <- base::withVisible(base::local({
[17:28:41.064]                 ...future.makeSendCondition <- base::local({
[17:28:41.064]                   sendCondition <- NULL
[17:28:41.064]                   function(frame = 1L) {
[17:28:41.064]                     if (is.function(sendCondition)) 
[17:28:41.064]                       return(sendCondition)
[17:28:41.064]                     ns <- getNamespace("parallel")
[17:28:41.064]                     if (exists("sendData", mode = "function", 
[17:28:41.064]                       envir = ns)) {
[17:28:41.064]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:41.064]                         envir = ns)
[17:28:41.064]                       envir <- sys.frame(frame)
[17:28:41.064]                       master <- NULL
[17:28:41.064]                       while (!identical(envir, .GlobalEnv) && 
[17:28:41.064]                         !identical(envir, emptyenv())) {
[17:28:41.064]                         if (exists("master", mode = "list", envir = envir, 
[17:28:41.064]                           inherits = FALSE)) {
[17:28:41.064]                           master <- get("master", mode = "list", 
[17:28:41.064]                             envir = envir, inherits = FALSE)
[17:28:41.064]                           if (inherits(master, c("SOCKnode", 
[17:28:41.064]                             "SOCK0node"))) {
[17:28:41.064]                             sendCondition <<- function(cond) {
[17:28:41.064]                               data <- list(type = "VALUE", value = cond, 
[17:28:41.064]                                 success = TRUE)
[17:28:41.064]                               parallel_sendData(master, data)
[17:28:41.064]                             }
[17:28:41.064]                             return(sendCondition)
[17:28:41.064]                           }
[17:28:41.064]                         }
[17:28:41.064]                         frame <- frame + 1L
[17:28:41.064]                         envir <- sys.frame(frame)
[17:28:41.064]                       }
[17:28:41.064]                     }
[17:28:41.064]                     sendCondition <<- function(cond) NULL
[17:28:41.064]                   }
[17:28:41.064]                 })
[17:28:41.064]                 withCallingHandlers({
[17:28:41.064]                   {
[17:28:41.064]                     value(future(subset(data, a == 2)))
[17:28:41.064]                   }
[17:28:41.064]                 }, immediateCondition = function(cond) {
[17:28:41.064]                   sendCondition <- ...future.makeSendCondition()
[17:28:41.064]                   sendCondition(cond)
[17:28:41.064]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.064]                   {
[17:28:41.064]                     inherits <- base::inherits
[17:28:41.064]                     invokeRestart <- base::invokeRestart
[17:28:41.064]                     is.null <- base::is.null
[17:28:41.064]                     muffled <- FALSE
[17:28:41.064]                     if (inherits(cond, "message")) {
[17:28:41.064]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:41.064]                       if (muffled) 
[17:28:41.064]                         invokeRestart("muffleMessage")
[17:28:41.064]                     }
[17:28:41.064]                     else if (inherits(cond, "warning")) {
[17:28:41.064]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:41.064]                       if (muffled) 
[17:28:41.064]                         invokeRestart("muffleWarning")
[17:28:41.064]                     }
[17:28:41.064]                     else if (inherits(cond, "condition")) {
[17:28:41.064]                       if (!is.null(pattern)) {
[17:28:41.064]                         computeRestarts <- base::computeRestarts
[17:28:41.064]                         grepl <- base::grepl
[17:28:41.064]                         restarts <- computeRestarts(cond)
[17:28:41.064]                         for (restart in restarts) {
[17:28:41.064]                           name <- restart$name
[17:28:41.064]                           if (is.null(name)) 
[17:28:41.064]                             next
[17:28:41.064]                           if (!grepl(pattern, name)) 
[17:28:41.064]                             next
[17:28:41.064]                           invokeRestart(restart)
[17:28:41.064]                           muffled <- TRUE
[17:28:41.064]                           break
[17:28:41.064]                         }
[17:28:41.064]                       }
[17:28:41.064]                     }
[17:28:41.064]                     invisible(muffled)
[17:28:41.064]                   }
[17:28:41.064]                   muffleCondition(cond)
[17:28:41.064]                 })
[17:28:41.064]             }))
[17:28:41.064]             future::FutureResult(value = ...future.value$value, 
[17:28:41.064]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.064]                   ...future.rng), globalenv = if (FALSE) 
[17:28:41.064]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:41.064]                     ...future.globalenv.names))
[17:28:41.064]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:41.064]         }, condition = base::local({
[17:28:41.064]             c <- base::c
[17:28:41.064]             inherits <- base::inherits
[17:28:41.064]             invokeRestart <- base::invokeRestart
[17:28:41.064]             length <- base::length
[17:28:41.064]             list <- base::list
[17:28:41.064]             seq.int <- base::seq.int
[17:28:41.064]             signalCondition <- base::signalCondition
[17:28:41.064]             sys.calls <- base::sys.calls
[17:28:41.064]             `[[` <- base::`[[`
[17:28:41.064]             `+` <- base::`+`
[17:28:41.064]             `<<-` <- base::`<<-`
[17:28:41.064]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:41.064]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:41.064]                   3L)]
[17:28:41.064]             }
[17:28:41.064]             function(cond) {
[17:28:41.064]                 is_error <- inherits(cond, "error")
[17:28:41.064]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:41.064]                   NULL)
[17:28:41.064]                 if (is_error) {
[17:28:41.064]                   sessionInformation <- function() {
[17:28:41.064]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:41.064]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:41.064]                       search = base::search(), system = base::Sys.info())
[17:28:41.064]                   }
[17:28:41.064]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.064]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:41.064]                     cond$call), session = sessionInformation(), 
[17:28:41.064]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:41.064]                   signalCondition(cond)
[17:28:41.064]                 }
[17:28:41.064]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:41.064]                 "immediateCondition"))) {
[17:28:41.064]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:41.064]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.064]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:41.064]                   if (TRUE && !signal) {
[17:28:41.064]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.064]                     {
[17:28:41.064]                       inherits <- base::inherits
[17:28:41.064]                       invokeRestart <- base::invokeRestart
[17:28:41.064]                       is.null <- base::is.null
[17:28:41.064]                       muffled <- FALSE
[17:28:41.064]                       if (inherits(cond, "message")) {
[17:28:41.064]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.064]                         if (muffled) 
[17:28:41.064]                           invokeRestart("muffleMessage")
[17:28:41.064]                       }
[17:28:41.064]                       else if (inherits(cond, "warning")) {
[17:28:41.064]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.064]                         if (muffled) 
[17:28:41.064]                           invokeRestart("muffleWarning")
[17:28:41.064]                       }
[17:28:41.064]                       else if (inherits(cond, "condition")) {
[17:28:41.064]                         if (!is.null(pattern)) {
[17:28:41.064]                           computeRestarts <- base::computeRestarts
[17:28:41.064]                           grepl <- base::grepl
[17:28:41.064]                           restarts <- computeRestarts(cond)
[17:28:41.064]                           for (restart in restarts) {
[17:28:41.064]                             name <- restart$name
[17:28:41.064]                             if (is.null(name)) 
[17:28:41.064]                               next
[17:28:41.064]                             if (!grepl(pattern, name)) 
[17:28:41.064]                               next
[17:28:41.064]                             invokeRestart(restart)
[17:28:41.064]                             muffled <- TRUE
[17:28:41.064]                             break
[17:28:41.064]                           }
[17:28:41.064]                         }
[17:28:41.064]                       }
[17:28:41.064]                       invisible(muffled)
[17:28:41.064]                     }
[17:28:41.064]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.064]                   }
[17:28:41.064]                 }
[17:28:41.064]                 else {
[17:28:41.064]                   if (TRUE) {
[17:28:41.064]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.064]                     {
[17:28:41.064]                       inherits <- base::inherits
[17:28:41.064]                       invokeRestart <- base::invokeRestart
[17:28:41.064]                       is.null <- base::is.null
[17:28:41.064]                       muffled <- FALSE
[17:28:41.064]                       if (inherits(cond, "message")) {
[17:28:41.064]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.064]                         if (muffled) 
[17:28:41.064]                           invokeRestart("muffleMessage")
[17:28:41.064]                       }
[17:28:41.064]                       else if (inherits(cond, "warning")) {
[17:28:41.064]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.064]                         if (muffled) 
[17:28:41.064]                           invokeRestart("muffleWarning")
[17:28:41.064]                       }
[17:28:41.064]                       else if (inherits(cond, "condition")) {
[17:28:41.064]                         if (!is.null(pattern)) {
[17:28:41.064]                           computeRestarts <- base::computeRestarts
[17:28:41.064]                           grepl <- base::grepl
[17:28:41.064]                           restarts <- computeRestarts(cond)
[17:28:41.064]                           for (restart in restarts) {
[17:28:41.064]                             name <- restart$name
[17:28:41.064]                             if (is.null(name)) 
[17:28:41.064]                               next
[17:28:41.064]                             if (!grepl(pattern, name)) 
[17:28:41.064]                               next
[17:28:41.064]                             invokeRestart(restart)
[17:28:41.064]                             muffled <- TRUE
[17:28:41.064]                             break
[17:28:41.064]                           }
[17:28:41.064]                         }
[17:28:41.064]                       }
[17:28:41.064]                       invisible(muffled)
[17:28:41.064]                     }
[17:28:41.064]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.064]                   }
[17:28:41.064]                 }
[17:28:41.064]             }
[17:28:41.064]         }))
[17:28:41.064]     }, error = function(ex) {
[17:28:41.064]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:41.064]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.064]                 ...future.rng), started = ...future.startTime, 
[17:28:41.064]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:41.064]             version = "1.8"), class = "FutureResult")
[17:28:41.064]     }, finally = {
[17:28:41.064]         if (!identical(...future.workdir, getwd())) 
[17:28:41.064]             setwd(...future.workdir)
[17:28:41.064]         {
[17:28:41.064]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:41.064]                 ...future.oldOptions$nwarnings <- NULL
[17:28:41.064]             }
[17:28:41.064]             base::options(...future.oldOptions)
[17:28:41.064]             if (.Platform$OS.type == "windows") {
[17:28:41.064]                 old_names <- names(...future.oldEnvVars)
[17:28:41.064]                 envs <- base::Sys.getenv()
[17:28:41.064]                 names <- names(envs)
[17:28:41.064]                 common <- intersect(names, old_names)
[17:28:41.064]                 added <- setdiff(names, old_names)
[17:28:41.064]                 removed <- setdiff(old_names, names)
[17:28:41.064]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:41.064]                   envs[common]]
[17:28:41.064]                 NAMES <- toupper(changed)
[17:28:41.064]                 args <- list()
[17:28:41.064]                 for (kk in seq_along(NAMES)) {
[17:28:41.064]                   name <- changed[[kk]]
[17:28:41.064]                   NAME <- NAMES[[kk]]
[17:28:41.064]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.064]                     next
[17:28:41.064]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.064]                 }
[17:28:41.064]                 NAMES <- toupper(added)
[17:28:41.064]                 for (kk in seq_along(NAMES)) {
[17:28:41.064]                   name <- added[[kk]]
[17:28:41.064]                   NAME <- NAMES[[kk]]
[17:28:41.064]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.064]                     next
[17:28:41.064]                   args[[name]] <- ""
[17:28:41.064]                 }
[17:28:41.064]                 NAMES <- toupper(removed)
[17:28:41.064]                 for (kk in seq_along(NAMES)) {
[17:28:41.064]                   name <- removed[[kk]]
[17:28:41.064]                   NAME <- NAMES[[kk]]
[17:28:41.064]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.064]                     next
[17:28:41.064]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.064]                 }
[17:28:41.064]                 if (length(args) > 0) 
[17:28:41.064]                   base::do.call(base::Sys.setenv, args = args)
[17:28:41.064]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:41.064]             }
[17:28:41.064]             else {
[17:28:41.064]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:41.064]             }
[17:28:41.064]             {
[17:28:41.064]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:41.064]                   0L) {
[17:28:41.064]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:41.064]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:41.064]                   base::options(opts)
[17:28:41.064]                 }
[17:28:41.064]                 {
[17:28:41.064]                   {
[17:28:41.064]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:41.064]                     NULL
[17:28:41.064]                   }
[17:28:41.064]                   options(future.plan = NULL)
[17:28:41.064]                   if (is.na(NA_character_)) 
[17:28:41.064]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.064]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:41.064]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:41.064]                     .init = FALSE)
[17:28:41.064]                 }
[17:28:41.064]             }
[17:28:41.064]         }
[17:28:41.064]     })
[17:28:41.064]     if (TRUE) {
[17:28:41.064]         base::sink(type = "output", split = FALSE)
[17:28:41.064]         if (TRUE) {
[17:28:41.064]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:41.064]         }
[17:28:41.064]         else {
[17:28:41.064]             ...future.result["stdout"] <- base::list(NULL)
[17:28:41.064]         }
[17:28:41.064]         base::close(...future.stdout)
[17:28:41.064]         ...future.stdout <- NULL
[17:28:41.064]     }
[17:28:41.064]     ...future.result$conditions <- ...future.conditions
[17:28:41.064]     ...future.result$finished <- base::Sys.time()
[17:28:41.064]     ...future.result
[17:28:41.064] }
[17:28:41.072] Exporting 1 global objects (639 bytes) to cluster node #1 ...
[17:28:41.072] Exporting 'data' (356 bytes) to cluster node #1 ...
[17:28:41.073] Exporting 'data' (356 bytes) to cluster node #1 ... DONE
[17:28:41.073] Exporting 1 global objects (639 bytes) to cluster node #1 ... DONE
[17:28:41.074] MultisessionFuture started
[17:28:41.074] - Launch lazy future ... done
[17:28:41.075] run() for 'MultisessionFuture' ... done
[17:28:41.075] result() for ClusterFuture ...
[17:28:41.075] receiveMessageFromWorker() for ClusterFuture ...
[17:28:41.076] - Validating connection of MultisessionFuture
[17:28:41.105] - received message: FutureResult
[17:28:41.106] - Received FutureResult
[17:28:41.106] - Erased future from FutureRegistry
[17:28:41.106] result() for ClusterFuture ...
[17:28:41.107] - result already collected: FutureResult
[17:28:41.107] result() for ClusterFuture ... done
[17:28:41.107] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:41.107] result() for ClusterFuture ... done
[17:28:41.107] result() for ClusterFuture ...
[17:28:41.107] - result already collected: FutureResult
[17:28:41.108] result() for ClusterFuture ... done
- plan(list('multisession', 'sequential')) ... DONE
- plan(list('multisession', 'multisession')) ...
[17:28:41.108] plan(): Setting new future strategy stack:
[17:28:41.108] List of future strategies:
[17:28:41.108] 1. multisession:
[17:28:41.108]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:41.108]    - tweaked: FALSE
[17:28:41.108]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:41.108] 2. multisession:
[17:28:41.108]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:41.108]    - tweaked: FALSE
[17:28:41.108]    - call: plan(list(a = strategy1, b = strategy2))
[17:28:41.119] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:41.119] multisession:
[17:28:41.119] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:41.119] - tweaked: FALSE
[17:28:41.119] - call: plan(list(a = strategy1, b = strategy2))
[17:28:41.125] getGlobalsAndPackages() ...
[17:28:41.125] Not searching for globals
[17:28:41.125] - globals: [0] <none>
[17:28:41.126] getGlobalsAndPackages() ... DONE
[17:28:41.127] [local output] makeClusterPSOCK() ...
[17:28:41.131] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:41.135] [local output] Base port: 25071
[17:28:41.136] [local output] Getting setup options for 2 cluster nodes ...
[17:28:41.136] [local output]  - Node #1 of 2 ...
[17:28:41.137] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:41.140] [local output] Rscript port: 25071

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

[17:28:41.144] [local output] Rscript port: 25071

[17:28:41.145] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:41.145] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:41.145] [local output] Setting up PSOCK nodes in parallel
[17:28:41.146] List of 36
[17:28:41.146]  $ worker          : chr "localhost"
[17:28:41.146]   ..- attr(*, "localhost")= logi TRUE
[17:28:41.146]  $ master          : chr "localhost"
[17:28:41.146]  $ port            : int 25071
[17:28:41.146]  $ connectTimeout  : num 120
[17:28:41.146]  $ timeout         : num 120
[17:28:41.146]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:41.146]  $ homogeneous     : logi TRUE
[17:28:41.146]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=nested_futures.R:108384:CRANWIN3"| __truncated__
[17:28:41.146]  $ rscript_envs    : NULL
[17:28:41.146]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:41.146]  $ rscript_startup : NULL
[17:28:41.146]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:28:41.146]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:41.146]  $ methods         : logi TRUE
[17:28:41.146]  $ socketOptions   : chr "no-delay"
[17:28:41.146]  $ useXDR          : logi FALSE
[17:28:41.146]  $ outfile         : chr "/dev/null"
[17:28:41.146]  $ renice          : int NA
[17:28:41.146]  $ rshcmd          : NULL
[17:28:41.146]  $ user            : chr(0) 
[17:28:41.146]  $ revtunnel       : logi FALSE
[17:28:41.146]  $ rshlogfile      : NULL
[17:28:41.146]  $ rshopts         : chr(0) 
[17:28:41.146]  $ rank            : int 1
[17:28:41.146]  $ manual          : logi FALSE
[17:28:41.146]  $ dryrun          : logi FALSE
[17:28:41.146]  $ quiet           : logi FALSE
[17:28:41.146]  $ setup_strategy  : chr "parallel"
[17:28:41.146]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:41.146]  $ pidfile         : chr "D:/temp/RtmpY1uheY/worker.rank=1.parallelly.parent=108384.1a7607f693831.pid"
[17:28:41.146]  $ rshcmd_label    : NULL
[17:28:41.146]  $ rsh_call        : NULL
[17:28:41.146]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:41.146]  $ localMachine    : logi TRUE
[17:28:41.146]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:41.146]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:41.146]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:41.146]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:41.146]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:41.146]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:28:41.146]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:28:41.146]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:41.146]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:41.146]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:41.146]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:41.146]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:41.146]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:41.146]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:41.146]  $ arguments       :List of 28
[17:28:41.146]   ..$ worker          : chr "localhost"
[17:28:41.146]   ..$ master          : NULL
[17:28:41.146]   ..$ port            : int 25071
[17:28:41.146]   ..$ connectTimeout  : num 120
[17:28:41.146]   ..$ timeout         : num 120
[17:28:41.146]   ..$ rscript         : NULL
[17:28:41.146]   ..$ homogeneous     : NULL
[17:28:41.146]   ..$ rscript_args    : NULL
[17:28:41.146]   ..$ rscript_envs    : NULL
[17:28:41.146]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:41.146]   ..$ rscript_startup : NULL
[17:28:41.146]   ..$ rscript_sh      : chr "auto"
[17:28:41.146]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:41.146]   ..$ methods         : logi TRUE
[17:28:41.146]   ..$ socketOptions   : chr "no-delay"
[17:28:41.146]   ..$ useXDR          : logi FALSE
[17:28:41.146]   ..$ outfile         : chr "/dev/null"
[17:28:41.146]   ..$ renice          : int NA
[17:28:41.146]   ..$ rshcmd          : NULL
[17:28:41.146]   ..$ user            : NULL
[17:28:41.146]   ..$ revtunnel       : logi NA
[17:28:41.146]   ..$ rshlogfile      : NULL
[17:28:41.146]   ..$ rshopts         : NULL
[17:28:41.146]   ..$ rank            : int 1
[17:28:41.146]   ..$ manual          : logi FALSE
[17:28:41.146]   ..$ dryrun          : logi FALSE
[17:28:41.146]   ..$ quiet           : logi FALSE
[17:28:41.146]   ..$ setup_strategy  : chr "parallel"
[17:28:41.146]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:41.180] [local output] System call to launch all workers:
[17:28:41.180] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=nested_futures.R:108384:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpY1uheY/worker.rank=1.parallelly.parent=108384.1a7607f693831.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25071 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:41.181] [local output] Starting PSOCK main server
[17:28:41.190] [local output] Workers launched
[17:28:41.190] [local output] Waiting for workers to connect back
[17:28:41.191]  - [local output] 0 workers out of 2 ready
[17:28:41.433]  - [local output] 0 workers out of 2 ready
[17:28:41.433]  - [local output] 1 workers out of 2 ready
[17:28:41.453]  - [local output] 1 workers out of 2 ready
[17:28:41.454]  - [local output] 2 workers out of 2 ready
[17:28:41.454] [local output] Launching of 2 workers completed
[17:28:41.454] [local output] Number of nodes in cluster: 2
[17:28:41.454] [local output] Collecting session information from 2 workers
[17:28:41.455] [local output]  - Worker #1 of 2
[17:28:41.456] [local output]  - Worker #2 of 2
[17:28:41.456] [local output] makeClusterPSOCK() ... done
[17:28:41.470] Packages needed by the future expression (n = 0): <none>
[17:28:41.470] Packages needed by future strategies (n = 1): 'future'
[17:28:41.471] {
[17:28:41.471]     {
[17:28:41.471]         {
[17:28:41.471]             ...future.startTime <- base::Sys.time()
[17:28:41.471]             {
[17:28:41.471]                 {
[17:28:41.471]                   {
[17:28:41.471]                     {
[17:28:41.471]                       {
[17:28:41.471]                         base::local({
[17:28:41.471]                           has_future <- base::requireNamespace("future", 
[17:28:41.471]                             quietly = TRUE)
[17:28:41.471]                           if (has_future) {
[17:28:41.471]                             ns <- base::getNamespace("future")
[17:28:41.471]                             version <- ns[[".package"]][["version"]]
[17:28:41.471]                             if (is.null(version)) 
[17:28:41.471]                               version <- utils::packageVersion("future")
[17:28:41.471]                           }
[17:28:41.471]                           else {
[17:28:41.471]                             version <- NULL
[17:28:41.471]                           }
[17:28:41.471]                           if (!has_future || version < "1.8.0") {
[17:28:41.471]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:41.471]                               "", base::R.version$version.string), 
[17:28:41.471]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:41.471]                                 base::R.version$platform, 8 * 
[17:28:41.471]                                   base::.Machine$sizeof.pointer), 
[17:28:41.471]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:41.471]                                 "release", "version")], collapse = " "), 
[17:28:41.471]                               hostname = base::Sys.info()[["nodename"]])
[17:28:41.471]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:41.471]                               info)
[17:28:41.471]                             info <- base::paste(info, collapse = "; ")
[17:28:41.471]                             if (!has_future) {
[17:28:41.471]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:41.471]                                 info)
[17:28:41.471]                             }
[17:28:41.471]                             else {
[17:28:41.471]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:41.471]                                 info, version)
[17:28:41.471]                             }
[17:28:41.471]                             base::stop(msg)
[17:28:41.471]                           }
[17:28:41.471]                         })
[17:28:41.471]                       }
[17:28:41.471]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:41.471]                       base::options(mc.cores = 1L)
[17:28:41.471]                     }
[17:28:41.471]                     base::local({
[17:28:41.471]                       for (pkg in "future") {
[17:28:41.471]                         base::loadNamespace(pkg)
[17:28:41.471]                         base::library(pkg, character.only = TRUE)
[17:28:41.471]                       }
[17:28:41.471]                     })
[17:28:41.471]                   }
[17:28:41.471]                   ...future.strategy.old <- future::plan("list")
[17:28:41.471]                   options(future.plan = NULL)
[17:28:41.471]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.471]                   future::plan(list(b = function (..., workers = availableCores(), 
[17:28:41.471]                     lazy = FALSE, rscript_libs = .libPaths(), 
[17:28:41.471]                     envir = parent.frame()) 
[17:28:41.471]                   {
[17:28:41.471]                     if (is.function(workers)) 
[17:28:41.471]                       workers <- workers()
[17:28:41.471]                     workers <- structure(as.integer(workers), 
[17:28:41.471]                       class = class(workers))
[17:28:41.471]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[17:28:41.471]                       workers >= 1)
[17:28:41.471]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[17:28:41.471]                       return(sequential(..., lazy = TRUE, envir = envir))
[17:28:41.471]                     }
[17:28:41.471]                     future <- MultisessionFuture(..., workers = workers, 
[17:28:41.471]                       lazy = lazy, rscript_libs = rscript_libs, 
[17:28:41.471]                       envir = envir)
[17:28:41.471]                     if (!future$lazy) 
[17:28:41.471]                       future <- run(future)
[17:28:41.471]                     invisible(future)
[17:28:41.471]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:41.471]                 }
[17:28:41.471]                 ...future.workdir <- getwd()
[17:28:41.471]             }
[17:28:41.471]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:41.471]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:41.471]         }
[17:28:41.471]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:41.471]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:41.471]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:41.471]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:41.471]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:41.471]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:41.471]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:41.471]             base::names(...future.oldOptions))
[17:28:41.471]     }
[17:28:41.471]     if (FALSE) {
[17:28:41.471]     }
[17:28:41.471]     else {
[17:28:41.471]         if (TRUE) {
[17:28:41.471]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:41.471]                 open = "w")
[17:28:41.471]         }
[17:28:41.471]         else {
[17:28:41.471]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:41.471]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:41.471]         }
[17:28:41.471]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:41.471]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:41.471]             base::sink(type = "output", split = FALSE)
[17:28:41.471]             base::close(...future.stdout)
[17:28:41.471]         }, add = TRUE)
[17:28:41.471]     }
[17:28:41.471]     ...future.frame <- base::sys.nframe()
[17:28:41.471]     ...future.conditions <- base::list()
[17:28:41.471]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:41.471]     if (FALSE) {
[17:28:41.471]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:41.471]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:41.471]     }
[17:28:41.471]     ...future.result <- base::tryCatch({
[17:28:41.471]         base::withCallingHandlers({
[17:28:41.471]             ...future.value <- base::withVisible(base::local({
[17:28:41.471]                 ...future.makeSendCondition <- base::local({
[17:28:41.471]                   sendCondition <- NULL
[17:28:41.471]                   function(frame = 1L) {
[17:28:41.471]                     if (is.function(sendCondition)) 
[17:28:41.471]                       return(sendCondition)
[17:28:41.471]                     ns <- getNamespace("parallel")
[17:28:41.471]                     if (exists("sendData", mode = "function", 
[17:28:41.471]                       envir = ns)) {
[17:28:41.471]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:41.471]                         envir = ns)
[17:28:41.471]                       envir <- sys.frame(frame)
[17:28:41.471]                       master <- NULL
[17:28:41.471]                       while (!identical(envir, .GlobalEnv) && 
[17:28:41.471]                         !identical(envir, emptyenv())) {
[17:28:41.471]                         if (exists("master", mode = "list", envir = envir, 
[17:28:41.471]                           inherits = FALSE)) {
[17:28:41.471]                           master <- get("master", mode = "list", 
[17:28:41.471]                             envir = envir, inherits = FALSE)
[17:28:41.471]                           if (inherits(master, c("SOCKnode", 
[17:28:41.471]                             "SOCK0node"))) {
[17:28:41.471]                             sendCondition <<- function(cond) {
[17:28:41.471]                               data <- list(type = "VALUE", value = cond, 
[17:28:41.471]                                 success = TRUE)
[17:28:41.471]                               parallel_sendData(master, data)
[17:28:41.471]                             }
[17:28:41.471]                             return(sendCondition)
[17:28:41.471]                           }
[17:28:41.471]                         }
[17:28:41.471]                         frame <- frame + 1L
[17:28:41.471]                         envir <- sys.frame(frame)
[17:28:41.471]                       }
[17:28:41.471]                     }
[17:28:41.471]                     sendCondition <<- function(cond) NULL
[17:28:41.471]                   }
[17:28:41.471]                 })
[17:28:41.471]                 withCallingHandlers({
[17:28:41.471]                   NA
[17:28:41.471]                 }, immediateCondition = function(cond) {
[17:28:41.471]                   sendCondition <- ...future.makeSendCondition()
[17:28:41.471]                   sendCondition(cond)
[17:28:41.471]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.471]                   {
[17:28:41.471]                     inherits <- base::inherits
[17:28:41.471]                     invokeRestart <- base::invokeRestart
[17:28:41.471]                     is.null <- base::is.null
[17:28:41.471]                     muffled <- FALSE
[17:28:41.471]                     if (inherits(cond, "message")) {
[17:28:41.471]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:41.471]                       if (muffled) 
[17:28:41.471]                         invokeRestart("muffleMessage")
[17:28:41.471]                     }
[17:28:41.471]                     else if (inherits(cond, "warning")) {
[17:28:41.471]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:41.471]                       if (muffled) 
[17:28:41.471]                         invokeRestart("muffleWarning")
[17:28:41.471]                     }
[17:28:41.471]                     else if (inherits(cond, "condition")) {
[17:28:41.471]                       if (!is.null(pattern)) {
[17:28:41.471]                         computeRestarts <- base::computeRestarts
[17:28:41.471]                         grepl <- base::grepl
[17:28:41.471]                         restarts <- computeRestarts(cond)
[17:28:41.471]                         for (restart in restarts) {
[17:28:41.471]                           name <- restart$name
[17:28:41.471]                           if (is.null(name)) 
[17:28:41.471]                             next
[17:28:41.471]                           if (!grepl(pattern, name)) 
[17:28:41.471]                             next
[17:28:41.471]                           invokeRestart(restart)
[17:28:41.471]                           muffled <- TRUE
[17:28:41.471]                           break
[17:28:41.471]                         }
[17:28:41.471]                       }
[17:28:41.471]                     }
[17:28:41.471]                     invisible(muffled)
[17:28:41.471]                   }
[17:28:41.471]                   muffleCondition(cond)
[17:28:41.471]                 })
[17:28:41.471]             }))
[17:28:41.471]             future::FutureResult(value = ...future.value$value, 
[17:28:41.471]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.471]                   ...future.rng), globalenv = if (FALSE) 
[17:28:41.471]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:41.471]                     ...future.globalenv.names))
[17:28:41.471]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:41.471]         }, condition = base::local({
[17:28:41.471]             c <- base::c
[17:28:41.471]             inherits <- base::inherits
[17:28:41.471]             invokeRestart <- base::invokeRestart
[17:28:41.471]             length <- base::length
[17:28:41.471]             list <- base::list
[17:28:41.471]             seq.int <- base::seq.int
[17:28:41.471]             signalCondition <- base::signalCondition
[17:28:41.471]             sys.calls <- base::sys.calls
[17:28:41.471]             `[[` <- base::`[[`
[17:28:41.471]             `+` <- base::`+`
[17:28:41.471]             `<<-` <- base::`<<-`
[17:28:41.471]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:41.471]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:41.471]                   3L)]
[17:28:41.471]             }
[17:28:41.471]             function(cond) {
[17:28:41.471]                 is_error <- inherits(cond, "error")
[17:28:41.471]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:41.471]                   NULL)
[17:28:41.471]                 if (is_error) {
[17:28:41.471]                   sessionInformation <- function() {
[17:28:41.471]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:41.471]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:41.471]                       search = base::search(), system = base::Sys.info())
[17:28:41.471]                   }
[17:28:41.471]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.471]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:41.471]                     cond$call), session = sessionInformation(), 
[17:28:41.471]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:41.471]                   signalCondition(cond)
[17:28:41.471]                 }
[17:28:41.471]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:41.471]                 "immediateCondition"))) {
[17:28:41.471]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:41.471]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.471]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:41.471]                   if (TRUE && !signal) {
[17:28:41.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.471]                     {
[17:28:41.471]                       inherits <- base::inherits
[17:28:41.471]                       invokeRestart <- base::invokeRestart
[17:28:41.471]                       is.null <- base::is.null
[17:28:41.471]                       muffled <- FALSE
[17:28:41.471]                       if (inherits(cond, "message")) {
[17:28:41.471]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.471]                         if (muffled) 
[17:28:41.471]                           invokeRestart("muffleMessage")
[17:28:41.471]                       }
[17:28:41.471]                       else if (inherits(cond, "warning")) {
[17:28:41.471]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.471]                         if (muffled) 
[17:28:41.471]                           invokeRestart("muffleWarning")
[17:28:41.471]                       }
[17:28:41.471]                       else if (inherits(cond, "condition")) {
[17:28:41.471]                         if (!is.null(pattern)) {
[17:28:41.471]                           computeRestarts <- base::computeRestarts
[17:28:41.471]                           grepl <- base::grepl
[17:28:41.471]                           restarts <- computeRestarts(cond)
[17:28:41.471]                           for (restart in restarts) {
[17:28:41.471]                             name <- restart$name
[17:28:41.471]                             if (is.null(name)) 
[17:28:41.471]                               next
[17:28:41.471]                             if (!grepl(pattern, name)) 
[17:28:41.471]                               next
[17:28:41.471]                             invokeRestart(restart)
[17:28:41.471]                             muffled <- TRUE
[17:28:41.471]                             break
[17:28:41.471]                           }
[17:28:41.471]                         }
[17:28:41.471]                       }
[17:28:41.471]                       invisible(muffled)
[17:28:41.471]                     }
[17:28:41.471]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.471]                   }
[17:28:41.471]                 }
[17:28:41.471]                 else {
[17:28:41.471]                   if (TRUE) {
[17:28:41.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.471]                     {
[17:28:41.471]                       inherits <- base::inherits
[17:28:41.471]                       invokeRestart <- base::invokeRestart
[17:28:41.471]                       is.null <- base::is.null
[17:28:41.471]                       muffled <- FALSE
[17:28:41.471]                       if (inherits(cond, "message")) {
[17:28:41.471]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.471]                         if (muffled) 
[17:28:41.471]                           invokeRestart("muffleMessage")
[17:28:41.471]                       }
[17:28:41.471]                       else if (inherits(cond, "warning")) {
[17:28:41.471]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.471]                         if (muffled) 
[17:28:41.471]                           invokeRestart("muffleWarning")
[17:28:41.471]                       }
[17:28:41.471]                       else if (inherits(cond, "condition")) {
[17:28:41.471]                         if (!is.null(pattern)) {
[17:28:41.471]                           computeRestarts <- base::computeRestarts
[17:28:41.471]                           grepl <- base::grepl
[17:28:41.471]                           restarts <- computeRestarts(cond)
[17:28:41.471]                           for (restart in restarts) {
[17:28:41.471]                             name <- restart$name
[17:28:41.471]                             if (is.null(name)) 
[17:28:41.471]                               next
[17:28:41.471]                             if (!grepl(pattern, name)) 
[17:28:41.471]                               next
[17:28:41.471]                             invokeRestart(restart)
[17:28:41.471]                             muffled <- TRUE
[17:28:41.471]                             break
[17:28:41.471]                           }
[17:28:41.471]                         }
[17:28:41.471]                       }
[17:28:41.471]                       invisible(muffled)
[17:28:41.471]                     }
[17:28:41.471]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.471]                   }
[17:28:41.471]                 }
[17:28:41.471]             }
[17:28:41.471]         }))
[17:28:41.471]     }, error = function(ex) {
[17:28:41.471]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:41.471]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.471]                 ...future.rng), started = ...future.startTime, 
[17:28:41.471]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:41.471]             version = "1.8"), class = "FutureResult")
[17:28:41.471]     }, finally = {
[17:28:41.471]         if (!identical(...future.workdir, getwd())) 
[17:28:41.471]             setwd(...future.workdir)
[17:28:41.471]         {
[17:28:41.471]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:41.471]                 ...future.oldOptions$nwarnings <- NULL
[17:28:41.471]             }
[17:28:41.471]             base::options(...future.oldOptions)
[17:28:41.471]             if (.Platform$OS.type == "windows") {
[17:28:41.471]                 old_names <- names(...future.oldEnvVars)
[17:28:41.471]                 envs <- base::Sys.getenv()
[17:28:41.471]                 names <- names(envs)
[17:28:41.471]                 common <- intersect(names, old_names)
[17:28:41.471]                 added <- setdiff(names, old_names)
[17:28:41.471]                 removed <- setdiff(old_names, names)
[17:28:41.471]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:41.471]                   envs[common]]
[17:28:41.471]                 NAMES <- toupper(changed)
[17:28:41.471]                 args <- list()
[17:28:41.471]                 for (kk in seq_along(NAMES)) {
[17:28:41.471]                   name <- changed[[kk]]
[17:28:41.471]                   NAME <- NAMES[[kk]]
[17:28:41.471]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.471]                     next
[17:28:41.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.471]                 }
[17:28:41.471]                 NAMES <- toupper(added)
[17:28:41.471]                 for (kk in seq_along(NAMES)) {
[17:28:41.471]                   name <- added[[kk]]
[17:28:41.471]                   NAME <- NAMES[[kk]]
[17:28:41.471]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.471]                     next
[17:28:41.471]                   args[[name]] <- ""
[17:28:41.471]                 }
[17:28:41.471]                 NAMES <- toupper(removed)
[17:28:41.471]                 for (kk in seq_along(NAMES)) {
[17:28:41.471]                   name <- removed[[kk]]
[17:28:41.471]                   NAME <- NAMES[[kk]]
[17:28:41.471]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.471]                     next
[17:28:41.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.471]                 }
[17:28:41.471]                 if (length(args) > 0) 
[17:28:41.471]                   base::do.call(base::Sys.setenv, args = args)
[17:28:41.471]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:41.471]             }
[17:28:41.471]             else {
[17:28:41.471]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:41.471]             }
[17:28:41.471]             {
[17:28:41.471]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:41.471]                   0L) {
[17:28:41.471]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:41.471]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:41.471]                   base::options(opts)
[17:28:41.471]                 }
[17:28:41.471]                 {
[17:28:41.471]                   {
[17:28:41.471]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:41.471]                     NULL
[17:28:41.471]                   }
[17:28:41.471]                   options(future.plan = NULL)
[17:28:41.471]                   if (is.na(NA_character_)) 
[17:28:41.471]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.471]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:41.471]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:41.471]                     .init = FALSE)
[17:28:41.471]                 }
[17:28:41.471]             }
[17:28:41.471]         }
[17:28:41.471]     })
[17:28:41.471]     if (TRUE) {
[17:28:41.471]         base::sink(type = "output", split = FALSE)
[17:28:41.471]         if (TRUE) {
[17:28:41.471]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:41.471]         }
[17:28:41.471]         else {
[17:28:41.471]             ...future.result["stdout"] <- base::list(NULL)
[17:28:41.471]         }
[17:28:41.471]         base::close(...future.stdout)
[17:28:41.471]         ...future.stdout <- NULL
[17:28:41.471]     }
[17:28:41.471]     ...future.result$conditions <- ...future.conditions
[17:28:41.471]     ...future.result$finished <- base::Sys.time()
[17:28:41.471]     ...future.result
[17:28:41.471] }
[17:28:41.617] MultisessionFuture started
[17:28:41.618] result() for ClusterFuture ...
[17:28:41.618] receiveMessageFromWorker() for ClusterFuture ...
[17:28:41.618] - Validating connection of MultisessionFuture
[17:28:41.735] - received message: FutureResult
[17:28:41.736] - Received FutureResult
[17:28:41.736] - Erased future from FutureRegistry
[17:28:41.736] result() for ClusterFuture ...
[17:28:41.737] - result already collected: FutureResult
[17:28:41.737] result() for ClusterFuture ... done
[17:28:41.737] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:41.737] result() for ClusterFuture ... done
[17:28:41.738] result() for ClusterFuture ...
[17:28:41.738] - result already collected: FutureResult
[17:28:41.738] result() for ClusterFuture ... done
[17:28:41.738] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:41.742] plan(): nbrOfWorkers() = 2
[17:28:41.743] getGlobalsAndPackages() ...
[17:28:41.743] Searching for globals...
[17:28:41.774] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[17:28:41.774] Searching for globals ... DONE
[17:28:41.775] Resolving globals: FALSE
[17:28:41.776] The total size of the 2 globals is 11.25 KiB (11520 bytes)
[17:28:41.777] The total size of the 2 globals exported for future expression ('{; a <- 1L; plan_a <- unclass(future::plan("list")); nested_a <- nested[-1]; stopifnot(length(nested_a) == 1L, length(plan_a) == 1L, inherits(plan_a[[1]],; "future"), inherits(future::plan("next"), strategy2)); ...; }; y; }') is 11.25 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (11.20 KiB of class 'list') and 'strategy2' (51 bytes of class 'character')
[17:28:41.777] - globals: [2] 'nested', 'strategy2'
[17:28:41.778] - packages: [1] 'future'
[17:28:41.778] getGlobalsAndPackages() ... DONE
[17:28:41.779] run() for 'Future' ...
[17:28:41.779] - state: 'created'
[17:28:41.779] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:41.797] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:41.798] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:41.798]   - Field: 'node'
[17:28:41.798]   - Field: 'label'
[17:28:41.799]   - Field: 'local'
[17:28:41.799]   - Field: 'owner'
[17:28:41.799]   - Field: 'envir'
[17:28:41.800]   - Field: 'workers'
[17:28:41.800]   - Field: 'packages'
[17:28:41.800]   - Field: 'gc'
[17:28:41.801]   - Field: 'conditions'
[17:28:41.801]   - Field: 'persistent'
[17:28:41.801]   - Field: 'expr'
[17:28:41.801]   - Field: 'uuid'
[17:28:41.801]   - Field: 'seed'
[17:28:41.802]   - Field: 'version'
[17:28:41.802]   - Field: 'result'
[17:28:41.802]   - Field: 'asynchronous'
[17:28:41.802]   - Field: 'calls'
[17:28:41.803]   - Field: 'globals'
[17:28:41.803]   - Field: 'stdout'
[17:28:41.804]   - Field: 'earlySignal'
[17:28:41.804]   - Field: 'lazy'
[17:28:41.804]   - Field: 'state'
[17:28:41.805] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:41.805] - Launch lazy future ...
[17:28:41.806] Packages needed by the future expression (n = 1): 'future'
[17:28:41.807] Packages needed by future strategies (n = 1): 'future'
[17:28:41.808] {
[17:28:41.808]     {
[17:28:41.808]         {
[17:28:41.808]             ...future.startTime <- base::Sys.time()
[17:28:41.808]             {
[17:28:41.808]                 {
[17:28:41.808]                   {
[17:28:41.808]                     {
[17:28:41.808]                       {
[17:28:41.808]                         base::local({
[17:28:41.808]                           has_future <- base::requireNamespace("future", 
[17:28:41.808]                             quietly = TRUE)
[17:28:41.808]                           if (has_future) {
[17:28:41.808]                             ns <- base::getNamespace("future")
[17:28:41.808]                             version <- ns[[".package"]][["version"]]
[17:28:41.808]                             if (is.null(version)) 
[17:28:41.808]                               version <- utils::packageVersion("future")
[17:28:41.808]                           }
[17:28:41.808]                           else {
[17:28:41.808]                             version <- NULL
[17:28:41.808]                           }
[17:28:41.808]                           if (!has_future || version < "1.8.0") {
[17:28:41.808]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:41.808]                               "", base::R.version$version.string), 
[17:28:41.808]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:41.808]                                 base::R.version$platform, 8 * 
[17:28:41.808]                                   base::.Machine$sizeof.pointer), 
[17:28:41.808]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:41.808]                                 "release", "version")], collapse = " "), 
[17:28:41.808]                               hostname = base::Sys.info()[["nodename"]])
[17:28:41.808]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:41.808]                               info)
[17:28:41.808]                             info <- base::paste(info, collapse = "; ")
[17:28:41.808]                             if (!has_future) {
[17:28:41.808]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:41.808]                                 info)
[17:28:41.808]                             }
[17:28:41.808]                             else {
[17:28:41.808]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:41.808]                                 info, version)
[17:28:41.808]                             }
[17:28:41.808]                             base::stop(msg)
[17:28:41.808]                           }
[17:28:41.808]                         })
[17:28:41.808]                       }
[17:28:41.808]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:41.808]                       base::options(mc.cores = 1L)
[17:28:41.808]                     }
[17:28:41.808]                     base::local({
[17:28:41.808]                       for (pkg in "future") {
[17:28:41.808]                         base::loadNamespace(pkg)
[17:28:41.808]                         base::library(pkg, character.only = TRUE)
[17:28:41.808]                       }
[17:28:41.808]                     })
[17:28:41.808]                   }
[17:28:41.808]                   ...future.strategy.old <- future::plan("list")
[17:28:41.808]                   options(future.plan = NULL)
[17:28:41.808]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.808]                   future::plan(list(b = function (..., workers = availableCores(), 
[17:28:41.808]                     lazy = FALSE, rscript_libs = .libPaths(), 
[17:28:41.808]                     envir = parent.frame()) 
[17:28:41.808]                   {
[17:28:41.808]                     if (is.function(workers)) 
[17:28:41.808]                       workers <- workers()
[17:28:41.808]                     workers <- structure(as.integer(workers), 
[17:28:41.808]                       class = class(workers))
[17:28:41.808]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[17:28:41.808]                       workers >= 1)
[17:28:41.808]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[17:28:41.808]                       return(sequential(..., lazy = TRUE, envir = envir))
[17:28:41.808]                     }
[17:28:41.808]                     future <- MultisessionFuture(..., workers = workers, 
[17:28:41.808]                       lazy = lazy, rscript_libs = rscript_libs, 
[17:28:41.808]                       envir = envir)
[17:28:41.808]                     if (!future$lazy) 
[17:28:41.808]                       future <- run(future)
[17:28:41.808]                     invisible(future)
[17:28:41.808]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:41.808]                 }
[17:28:41.808]                 ...future.workdir <- getwd()
[17:28:41.808]             }
[17:28:41.808]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:41.808]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:41.808]         }
[17:28:41.808]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:41.808]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:41.808]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:41.808]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:41.808]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:41.808]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:41.808]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:41.808]             base::names(...future.oldOptions))
[17:28:41.808]     }
[17:28:41.808]     if (FALSE) {
[17:28:41.808]     }
[17:28:41.808]     else {
[17:28:41.808]         if (TRUE) {
[17:28:41.808]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:41.808]                 open = "w")
[17:28:41.808]         }
[17:28:41.808]         else {
[17:28:41.808]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:41.808]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:41.808]         }
[17:28:41.808]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:41.808]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:41.808]             base::sink(type = "output", split = FALSE)
[17:28:41.808]             base::close(...future.stdout)
[17:28:41.808]         }, add = TRUE)
[17:28:41.808]     }
[17:28:41.808]     ...future.frame <- base::sys.nframe()
[17:28:41.808]     ...future.conditions <- base::list()
[17:28:41.808]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:41.808]     if (FALSE) {
[17:28:41.808]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:41.808]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:41.808]     }
[17:28:41.808]     ...future.result <- base::tryCatch({
[17:28:41.808]         base::withCallingHandlers({
[17:28:41.808]             ...future.value <- base::withVisible(base::local({
[17:28:41.808]                 ...future.makeSendCondition <- base::local({
[17:28:41.808]                   sendCondition <- NULL
[17:28:41.808]                   function(frame = 1L) {
[17:28:41.808]                     if (is.function(sendCondition)) 
[17:28:41.808]                       return(sendCondition)
[17:28:41.808]                     ns <- getNamespace("parallel")
[17:28:41.808]                     if (exists("sendData", mode = "function", 
[17:28:41.808]                       envir = ns)) {
[17:28:41.808]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:41.808]                         envir = ns)
[17:28:41.808]                       envir <- sys.frame(frame)
[17:28:41.808]                       master <- NULL
[17:28:41.808]                       while (!identical(envir, .GlobalEnv) && 
[17:28:41.808]                         !identical(envir, emptyenv())) {
[17:28:41.808]                         if (exists("master", mode = "list", envir = envir, 
[17:28:41.808]                           inherits = FALSE)) {
[17:28:41.808]                           master <- get("master", mode = "list", 
[17:28:41.808]                             envir = envir, inherits = FALSE)
[17:28:41.808]                           if (inherits(master, c("SOCKnode", 
[17:28:41.808]                             "SOCK0node"))) {
[17:28:41.808]                             sendCondition <<- function(cond) {
[17:28:41.808]                               data <- list(type = "VALUE", value = cond, 
[17:28:41.808]                                 success = TRUE)
[17:28:41.808]                               parallel_sendData(master, data)
[17:28:41.808]                             }
[17:28:41.808]                             return(sendCondition)
[17:28:41.808]                           }
[17:28:41.808]                         }
[17:28:41.808]                         frame <- frame + 1L
[17:28:41.808]                         envir <- sys.frame(frame)
[17:28:41.808]                       }
[17:28:41.808]                     }
[17:28:41.808]                     sendCondition <<- function(cond) NULL
[17:28:41.808]                   }
[17:28:41.808]                 })
[17:28:41.808]                 withCallingHandlers({
[17:28:41.808]                   {
[17:28:41.808]                     a <- 1L
[17:28:41.808]                     plan_a <- unclass(future::plan("list"))
[17:28:41.808]                     nested_a <- nested[-1]
[17:28:41.808]                     stopifnot(length(nested_a) == 1L, length(plan_a) == 
[17:28:41.808]                       1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[17:28:41.808]                       strategy2))
[17:28:41.808]                     for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[17:28:41.808]                       "init") <- NULL
[17:28:41.808]                     for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[17:28:41.808]                       "init") <- NULL
[17:28:41.808]                     stopifnot(all.equal(plan_a, nested_a))
[17:28:41.808]                     y %<-% {
[17:28:41.808]                       b <- 2L
[17:28:41.808]                       plan_b <- future::plan("list")
[17:28:41.808]                       nested_b <- nested_a[-1]
[17:28:41.808]                       stopifnot(length(nested_b) == 0L, length(plan_b) == 
[17:28:41.808]                         1L, inherits(plan_b[[1]], "future"), 
[17:28:41.808]                         inherits(future::plan("next"), "sequential"))
[17:28:41.808]                       list(a = a, nested_a = nested_a, plan_a = plan_a, 
[17:28:41.808]                         b = b, nested_b = nested_b, plan_b = plan_b)
[17:28:41.808]                     }
[17:28:41.808]                     y
[17:28:41.808]                   }
[17:28:41.808]                 }, immediateCondition = function(cond) {
[17:28:41.808]                   sendCondition <- ...future.makeSendCondition()
[17:28:41.808]                   sendCondition(cond)
[17:28:41.808]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.808]                   {
[17:28:41.808]                     inherits <- base::inherits
[17:28:41.808]                     invokeRestart <- base::invokeRestart
[17:28:41.808]                     is.null <- base::is.null
[17:28:41.808]                     muffled <- FALSE
[17:28:41.808]                     if (inherits(cond, "message")) {
[17:28:41.808]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:41.808]                       if (muffled) 
[17:28:41.808]                         invokeRestart("muffleMessage")
[17:28:41.808]                     }
[17:28:41.808]                     else if (inherits(cond, "warning")) {
[17:28:41.808]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:41.808]                       if (muffled) 
[17:28:41.808]                         invokeRestart("muffleWarning")
[17:28:41.808]                     }
[17:28:41.808]                     else if (inherits(cond, "condition")) {
[17:28:41.808]                       if (!is.null(pattern)) {
[17:28:41.808]                         computeRestarts <- base::computeRestarts
[17:28:41.808]                         grepl <- base::grepl
[17:28:41.808]                         restarts <- computeRestarts(cond)
[17:28:41.808]                         for (restart in restarts) {
[17:28:41.808]                           name <- restart$name
[17:28:41.808]                           if (is.null(name)) 
[17:28:41.808]                             next
[17:28:41.808]                           if (!grepl(pattern, name)) 
[17:28:41.808]                             next
[17:28:41.808]                           invokeRestart(restart)
[17:28:41.808]                           muffled <- TRUE
[17:28:41.808]                           break
[17:28:41.808]                         }
[17:28:41.808]                       }
[17:28:41.808]                     }
[17:28:41.808]                     invisible(muffled)
[17:28:41.808]                   }
[17:28:41.808]                   muffleCondition(cond)
[17:28:41.808]                 })
[17:28:41.808]             }))
[17:28:41.808]             future::FutureResult(value = ...future.value$value, 
[17:28:41.808]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.808]                   ...future.rng), globalenv = if (FALSE) 
[17:28:41.808]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:41.808]                     ...future.globalenv.names))
[17:28:41.808]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:41.808]         }, condition = base::local({
[17:28:41.808]             c <- base::c
[17:28:41.808]             inherits <- base::inherits
[17:28:41.808]             invokeRestart <- base::invokeRestart
[17:28:41.808]             length <- base::length
[17:28:41.808]             list <- base::list
[17:28:41.808]             seq.int <- base::seq.int
[17:28:41.808]             signalCondition <- base::signalCondition
[17:28:41.808]             sys.calls <- base::sys.calls
[17:28:41.808]             `[[` <- base::`[[`
[17:28:41.808]             `+` <- base::`+`
[17:28:41.808]             `<<-` <- base::`<<-`
[17:28:41.808]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:41.808]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:41.808]                   3L)]
[17:28:41.808]             }
[17:28:41.808]             function(cond) {
[17:28:41.808]                 is_error <- inherits(cond, "error")
[17:28:41.808]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:41.808]                   NULL)
[17:28:41.808]                 if (is_error) {
[17:28:41.808]                   sessionInformation <- function() {
[17:28:41.808]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:41.808]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:41.808]                       search = base::search(), system = base::Sys.info())
[17:28:41.808]                   }
[17:28:41.808]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.808]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:41.808]                     cond$call), session = sessionInformation(), 
[17:28:41.808]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:41.808]                   signalCondition(cond)
[17:28:41.808]                 }
[17:28:41.808]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:41.808]                 "immediateCondition"))) {
[17:28:41.808]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:41.808]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.808]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:41.808]                   if (TRUE && !signal) {
[17:28:41.808]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.808]                     {
[17:28:41.808]                       inherits <- base::inherits
[17:28:41.808]                       invokeRestart <- base::invokeRestart
[17:28:41.808]                       is.null <- base::is.null
[17:28:41.808]                       muffled <- FALSE
[17:28:41.808]                       if (inherits(cond, "message")) {
[17:28:41.808]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.808]                         if (muffled) 
[17:28:41.808]                           invokeRestart("muffleMessage")
[17:28:41.808]                       }
[17:28:41.808]                       else if (inherits(cond, "warning")) {
[17:28:41.808]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.808]                         if (muffled) 
[17:28:41.808]                           invokeRestart("muffleWarning")
[17:28:41.808]                       }
[17:28:41.808]                       else if (inherits(cond, "condition")) {
[17:28:41.808]                         if (!is.null(pattern)) {
[17:28:41.808]                           computeRestarts <- base::computeRestarts
[17:28:41.808]                           grepl <- base::grepl
[17:28:41.808]                           restarts <- computeRestarts(cond)
[17:28:41.808]                           for (restart in restarts) {
[17:28:41.808]                             name <- restart$name
[17:28:41.808]                             if (is.null(name)) 
[17:28:41.808]                               next
[17:28:41.808]                             if (!grepl(pattern, name)) 
[17:28:41.808]                               next
[17:28:41.808]                             invokeRestart(restart)
[17:28:41.808]                             muffled <- TRUE
[17:28:41.808]                             break
[17:28:41.808]                           }
[17:28:41.808]                         }
[17:28:41.808]                       }
[17:28:41.808]                       invisible(muffled)
[17:28:41.808]                     }
[17:28:41.808]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.808]                   }
[17:28:41.808]                 }
[17:28:41.808]                 else {
[17:28:41.808]                   if (TRUE) {
[17:28:41.808]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.808]                     {
[17:28:41.808]                       inherits <- base::inherits
[17:28:41.808]                       invokeRestart <- base::invokeRestart
[17:28:41.808]                       is.null <- base::is.null
[17:28:41.808]                       muffled <- FALSE
[17:28:41.808]                       if (inherits(cond, "message")) {
[17:28:41.808]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.808]                         if (muffled) 
[17:28:41.808]                           invokeRestart("muffleMessage")
[17:28:41.808]                       }
[17:28:41.808]                       else if (inherits(cond, "warning")) {
[17:28:41.808]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.808]                         if (muffled) 
[17:28:41.808]                           invokeRestart("muffleWarning")
[17:28:41.808]                       }
[17:28:41.808]                       else if (inherits(cond, "condition")) {
[17:28:41.808]                         if (!is.null(pattern)) {
[17:28:41.808]                           computeRestarts <- base::computeRestarts
[17:28:41.808]                           grepl <- base::grepl
[17:28:41.808]                           restarts <- computeRestarts(cond)
[17:28:41.808]                           for (restart in restarts) {
[17:28:41.808]                             name <- restart$name
[17:28:41.808]                             if (is.null(name)) 
[17:28:41.808]                               next
[17:28:41.808]                             if (!grepl(pattern, name)) 
[17:28:41.808]                               next
[17:28:41.808]                             invokeRestart(restart)
[17:28:41.808]                             muffled <- TRUE
[17:28:41.808]                             break
[17:28:41.808]                           }
[17:28:41.808]                         }
[17:28:41.808]                       }
[17:28:41.808]                       invisible(muffled)
[17:28:41.808]                     }
[17:28:41.808]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.808]                   }
[17:28:41.808]                 }
[17:28:41.808]             }
[17:28:41.808]         }))
[17:28:41.808]     }, error = function(ex) {
[17:28:41.808]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:41.808]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.808]                 ...future.rng), started = ...future.startTime, 
[17:28:41.808]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:41.808]             version = "1.8"), class = "FutureResult")
[17:28:41.808]     }, finally = {
[17:28:41.808]         if (!identical(...future.workdir, getwd())) 
[17:28:41.808]             setwd(...future.workdir)
[17:28:41.808]         {
[17:28:41.808]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:41.808]                 ...future.oldOptions$nwarnings <- NULL
[17:28:41.808]             }
[17:28:41.808]             base::options(...future.oldOptions)
[17:28:41.808]             if (.Platform$OS.type == "windows") {
[17:28:41.808]                 old_names <- names(...future.oldEnvVars)
[17:28:41.808]                 envs <- base::Sys.getenv()
[17:28:41.808]                 names <- names(envs)
[17:28:41.808]                 common <- intersect(names, old_names)
[17:28:41.808]                 added <- setdiff(names, old_names)
[17:28:41.808]                 removed <- setdiff(old_names, names)
[17:28:41.808]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:41.808]                   envs[common]]
[17:28:41.808]                 NAMES <- toupper(changed)
[17:28:41.808]                 args <- list()
[17:28:41.808]                 for (kk in seq_along(NAMES)) {
[17:28:41.808]                   name <- changed[[kk]]
[17:28:41.808]                   NAME <- NAMES[[kk]]
[17:28:41.808]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.808]                     next
[17:28:41.808]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.808]                 }
[17:28:41.808]                 NAMES <- toupper(added)
[17:28:41.808]                 for (kk in seq_along(NAMES)) {
[17:28:41.808]                   name <- added[[kk]]
[17:28:41.808]                   NAME <- NAMES[[kk]]
[17:28:41.808]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.808]                     next
[17:28:41.808]                   args[[name]] <- ""
[17:28:41.808]                 }
[17:28:41.808]                 NAMES <- toupper(removed)
[17:28:41.808]                 for (kk in seq_along(NAMES)) {
[17:28:41.808]                   name <- removed[[kk]]
[17:28:41.808]                   NAME <- NAMES[[kk]]
[17:28:41.808]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.808]                     next
[17:28:41.808]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.808]                 }
[17:28:41.808]                 if (length(args) > 0) 
[17:28:41.808]                   base::do.call(base::Sys.setenv, args = args)
[17:28:41.808]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:41.808]             }
[17:28:41.808]             else {
[17:28:41.808]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:41.808]             }
[17:28:41.808]             {
[17:28:41.808]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:41.808]                   0L) {
[17:28:41.808]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:41.808]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:41.808]                   base::options(opts)
[17:28:41.808]                 }
[17:28:41.808]                 {
[17:28:41.808]                   {
[17:28:41.808]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:41.808]                     NULL
[17:28:41.808]                   }
[17:28:41.808]                   options(future.plan = NULL)
[17:28:41.808]                   if (is.na(NA_character_)) 
[17:28:41.808]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.808]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:41.808]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:41.808]                     .init = FALSE)
[17:28:41.808]                 }
[17:28:41.808]             }
[17:28:41.808]         }
[17:28:41.808]     })
[17:28:41.808]     if (TRUE) {
[17:28:41.808]         base::sink(type = "output", split = FALSE)
[17:28:41.808]         if (TRUE) {
[17:28:41.808]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:41.808]         }
[17:28:41.808]         else {
[17:28:41.808]             ...future.result["stdout"] <- base::list(NULL)
[17:28:41.808]         }
[17:28:41.808]         base::close(...future.stdout)
[17:28:41.808]         ...future.stdout <- NULL
[17:28:41.808]     }
[17:28:41.808]     ...future.result$conditions <- ...future.conditions
[17:28:41.808]     ...future.result$finished <- base::Sys.time()
[17:28:41.808]     ...future.result
[17:28:41.808] }
[17:28:41.820] Exporting 2 global objects (11.54 KiB) to cluster node #1 ...
[17:28:41.820] Exporting 'nested' (11.20 KiB) to cluster node #1 ...
[17:28:41.821] Exporting 'nested' (11.20 KiB) to cluster node #1 ... DONE
[17:28:41.822] Exporting 'strategy2' (51 bytes) to cluster node #1 ...
[17:28:41.822] Exporting 'strategy2' (51 bytes) to cluster node #1 ... DONE
[17:28:41.823] Exporting 2 global objects (11.54 KiB) to cluster node #1 ... DONE
[17:28:41.824] MultisessionFuture started
[17:28:41.824] - Launch lazy future ... done
[17:28:41.825] run() for 'MultisessionFuture' ... done
[17:28:41.825] result() for ClusterFuture ...
[17:28:41.825] receiveMessageFromWorker() for ClusterFuture ...
[17:28:41.826] - Validating connection of MultisessionFuture
[17:28:41.910] - received message: FutureResult
[17:28:41.910] - Received FutureResult
[17:28:41.911] - Erased future from FutureRegistry
[17:28:41.911] result() for ClusterFuture ...
[17:28:41.911] - result already collected: FutureResult
[17:28:41.911] result() for ClusterFuture ... done
[17:28:41.912] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:41.912] result() for ClusterFuture ... done
[17:28:41.912] result() for ClusterFuture ...
[17:28:41.912] - result already collected: FutureResult
[17:28:41.913] result() for ClusterFuture ... done
List of 6
 $ a       : int 1
 $ nested_a:List of 1
  ..$ b:function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), 
    envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:5] "multisession" "cluster" "multiprocess" "future" ...
  .. ..- attr(*, "cleanup")=function ()  
  .. ..- attr(*, "untweakable")= chr "persistent"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ plan_a  :List of 1
  ..$ b:function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), 
    envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:5] "multisession" "cluster" "multiprocess" "future" ...
  .. ..- attr(*, "cleanup")=function ()  
  .. ..- attr(*, "untweakable")= chr "persistent"
  .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
 $ b       : int 2
 $ nested_b: Named list()
 $ plan_b  :List of 1
  ..$ :function (..., envir = parent.frame())  
  .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
  ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[17:28:41.925] getGlobalsAndPackages() ...
[17:28:41.925] Searching for globals...
[17:28:41.927] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[17:28:41.927] Searching for globals ... DONE
[17:28:41.927] Resolving globals: FALSE
[17:28:41.928] The total size of the 1 globals is 356 bytes (356 bytes)
[17:28:41.928] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 356 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (356 bytes of class 'list')
[17:28:41.929] - globals: [1] 'data'
[17:28:41.929] - packages: [1] 'future'
[17:28:41.929] getGlobalsAndPackages() ... DONE
[17:28:41.929] run() for 'Future' ...
[17:28:41.930] - state: 'created'
[17:28:41.930] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:41.950] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:41.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:41.951]   - Field: 'node'
[17:28:41.951]   - Field: 'label'
[17:28:41.952]   - Field: 'local'
[17:28:41.952]   - Field: 'owner'
[17:28:41.952]   - Field: 'envir'
[17:28:41.953]   - Field: 'workers'
[17:28:41.953]   - Field: 'packages'
[17:28:41.953]   - Field: 'gc'
[17:28:41.953]   - Field: 'conditions'
[17:28:41.954]   - Field: 'persistent'
[17:28:41.954]   - Field: 'expr'
[17:28:41.954]   - Field: 'uuid'
[17:28:41.955]   - Field: 'seed'
[17:28:41.955]   - Field: 'version'
[17:28:41.955]   - Field: 'result'
[17:28:41.956]   - Field: 'asynchronous'
[17:28:41.956]   - Field: 'calls'
[17:28:41.956]   - Field: 'globals'
[17:28:41.956]   - Field: 'stdout'
[17:28:41.956]   - Field: 'earlySignal'
[17:28:41.957]   - Field: 'lazy'
[17:28:41.957]   - Field: 'state'
[17:28:41.957] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:41.957] - Launch lazy future ...
[17:28:41.958] Packages needed by the future expression (n = 1): 'future'
[17:28:41.958] Packages needed by future strategies (n = 1): 'future'
[17:28:41.959] {
[17:28:41.959]     {
[17:28:41.959]         {
[17:28:41.959]             ...future.startTime <- base::Sys.time()
[17:28:41.959]             {
[17:28:41.959]                 {
[17:28:41.959]                   {
[17:28:41.959]                     {
[17:28:41.959]                       {
[17:28:41.959]                         base::local({
[17:28:41.959]                           has_future <- base::requireNamespace("future", 
[17:28:41.959]                             quietly = TRUE)
[17:28:41.959]                           if (has_future) {
[17:28:41.959]                             ns <- base::getNamespace("future")
[17:28:41.959]                             version <- ns[[".package"]][["version"]]
[17:28:41.959]                             if (is.null(version)) 
[17:28:41.959]                               version <- utils::packageVersion("future")
[17:28:41.959]                           }
[17:28:41.959]                           else {
[17:28:41.959]                             version <- NULL
[17:28:41.959]                           }
[17:28:41.959]                           if (!has_future || version < "1.8.0") {
[17:28:41.959]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:41.959]                               "", base::R.version$version.string), 
[17:28:41.959]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:41.959]                                 base::R.version$platform, 8 * 
[17:28:41.959]                                   base::.Machine$sizeof.pointer), 
[17:28:41.959]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:41.959]                                 "release", "version")], collapse = " "), 
[17:28:41.959]                               hostname = base::Sys.info()[["nodename"]])
[17:28:41.959]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:41.959]                               info)
[17:28:41.959]                             info <- base::paste(info, collapse = "; ")
[17:28:41.959]                             if (!has_future) {
[17:28:41.959]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:41.959]                                 info)
[17:28:41.959]                             }
[17:28:41.959]                             else {
[17:28:41.959]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:41.959]                                 info, version)
[17:28:41.959]                             }
[17:28:41.959]                             base::stop(msg)
[17:28:41.959]                           }
[17:28:41.959]                         })
[17:28:41.959]                       }
[17:28:41.959]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:41.959]                       base::options(mc.cores = 1L)
[17:28:41.959]                     }
[17:28:41.959]                     base::local({
[17:28:41.959]                       for (pkg in "future") {
[17:28:41.959]                         base::loadNamespace(pkg)
[17:28:41.959]                         base::library(pkg, character.only = TRUE)
[17:28:41.959]                       }
[17:28:41.959]                     })
[17:28:41.959]                   }
[17:28:41.959]                   ...future.strategy.old <- future::plan("list")
[17:28:41.959]                   options(future.plan = NULL)
[17:28:41.959]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.959]                   future::plan(list(b = function (..., workers = availableCores(), 
[17:28:41.959]                     lazy = FALSE, rscript_libs = .libPaths(), 
[17:28:41.959]                     envir = parent.frame()) 
[17:28:41.959]                   {
[17:28:41.959]                     if (is.function(workers)) 
[17:28:41.959]                       workers <- workers()
[17:28:41.959]                     workers <- structure(as.integer(workers), 
[17:28:41.959]                       class = class(workers))
[17:28:41.959]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[17:28:41.959]                       workers >= 1)
[17:28:41.959]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[17:28:41.959]                       return(sequential(..., lazy = TRUE, envir = envir))
[17:28:41.959]                     }
[17:28:41.959]                     future <- MultisessionFuture(..., workers = workers, 
[17:28:41.959]                       lazy = lazy, rscript_libs = rscript_libs, 
[17:28:41.959]                       envir = envir)
[17:28:41.959]                     if (!future$lazy) 
[17:28:41.959]                       future <- run(future)
[17:28:41.959]                     invisible(future)
[17:28:41.959]                   }), .cleanup = FALSE, .init = FALSE)
[17:28:41.959]                 }
[17:28:41.959]                 ...future.workdir <- getwd()
[17:28:41.959]             }
[17:28:41.959]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:41.959]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:41.959]         }
[17:28:41.959]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:41.959]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:41.959]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:41.959]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:41.959]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:41.959]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:41.959]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:41.959]             base::names(...future.oldOptions))
[17:28:41.959]     }
[17:28:41.959]     if (FALSE) {
[17:28:41.959]     }
[17:28:41.959]     else {
[17:28:41.959]         if (TRUE) {
[17:28:41.959]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:41.959]                 open = "w")
[17:28:41.959]         }
[17:28:41.959]         else {
[17:28:41.959]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:41.959]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:41.959]         }
[17:28:41.959]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:41.959]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:41.959]             base::sink(type = "output", split = FALSE)
[17:28:41.959]             base::close(...future.stdout)
[17:28:41.959]         }, add = TRUE)
[17:28:41.959]     }
[17:28:41.959]     ...future.frame <- base::sys.nframe()
[17:28:41.959]     ...future.conditions <- base::list()
[17:28:41.959]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:41.959]     if (FALSE) {
[17:28:41.959]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:41.959]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:41.959]     }
[17:28:41.959]     ...future.result <- base::tryCatch({
[17:28:41.959]         base::withCallingHandlers({
[17:28:41.959]             ...future.value <- base::withVisible(base::local({
[17:28:41.959]                 ...future.makeSendCondition <- base::local({
[17:28:41.959]                   sendCondition <- NULL
[17:28:41.959]                   function(frame = 1L) {
[17:28:41.959]                     if (is.function(sendCondition)) 
[17:28:41.959]                       return(sendCondition)
[17:28:41.959]                     ns <- getNamespace("parallel")
[17:28:41.959]                     if (exists("sendData", mode = "function", 
[17:28:41.959]                       envir = ns)) {
[17:28:41.959]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:41.959]                         envir = ns)
[17:28:41.959]                       envir <- sys.frame(frame)
[17:28:41.959]                       master <- NULL
[17:28:41.959]                       while (!identical(envir, .GlobalEnv) && 
[17:28:41.959]                         !identical(envir, emptyenv())) {
[17:28:41.959]                         if (exists("master", mode = "list", envir = envir, 
[17:28:41.959]                           inherits = FALSE)) {
[17:28:41.959]                           master <- get("master", mode = "list", 
[17:28:41.959]                             envir = envir, inherits = FALSE)
[17:28:41.959]                           if (inherits(master, c("SOCKnode", 
[17:28:41.959]                             "SOCK0node"))) {
[17:28:41.959]                             sendCondition <<- function(cond) {
[17:28:41.959]                               data <- list(type = "VALUE", value = cond, 
[17:28:41.959]                                 success = TRUE)
[17:28:41.959]                               parallel_sendData(master, data)
[17:28:41.959]                             }
[17:28:41.959]                             return(sendCondition)
[17:28:41.959]                           }
[17:28:41.959]                         }
[17:28:41.959]                         frame <- frame + 1L
[17:28:41.959]                         envir <- sys.frame(frame)
[17:28:41.959]                       }
[17:28:41.959]                     }
[17:28:41.959]                     sendCondition <<- function(cond) NULL
[17:28:41.959]                   }
[17:28:41.959]                 })
[17:28:41.959]                 withCallingHandlers({
[17:28:41.959]                   {
[17:28:41.959]                     value(future(subset(data, a == 2)))
[17:28:41.959]                   }
[17:28:41.959]                 }, immediateCondition = function(cond) {
[17:28:41.959]                   sendCondition <- ...future.makeSendCondition()
[17:28:41.959]                   sendCondition(cond)
[17:28:41.959]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.959]                   {
[17:28:41.959]                     inherits <- base::inherits
[17:28:41.959]                     invokeRestart <- base::invokeRestart
[17:28:41.959]                     is.null <- base::is.null
[17:28:41.959]                     muffled <- FALSE
[17:28:41.959]                     if (inherits(cond, "message")) {
[17:28:41.959]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:41.959]                       if (muffled) 
[17:28:41.959]                         invokeRestart("muffleMessage")
[17:28:41.959]                     }
[17:28:41.959]                     else if (inherits(cond, "warning")) {
[17:28:41.959]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:41.959]                       if (muffled) 
[17:28:41.959]                         invokeRestart("muffleWarning")
[17:28:41.959]                     }
[17:28:41.959]                     else if (inherits(cond, "condition")) {
[17:28:41.959]                       if (!is.null(pattern)) {
[17:28:41.959]                         computeRestarts <- base::computeRestarts
[17:28:41.959]                         grepl <- base::grepl
[17:28:41.959]                         restarts <- computeRestarts(cond)
[17:28:41.959]                         for (restart in restarts) {
[17:28:41.959]                           name <- restart$name
[17:28:41.959]                           if (is.null(name)) 
[17:28:41.959]                             next
[17:28:41.959]                           if (!grepl(pattern, name)) 
[17:28:41.959]                             next
[17:28:41.959]                           invokeRestart(restart)
[17:28:41.959]                           muffled <- TRUE
[17:28:41.959]                           break
[17:28:41.959]                         }
[17:28:41.959]                       }
[17:28:41.959]                     }
[17:28:41.959]                     invisible(muffled)
[17:28:41.959]                   }
[17:28:41.959]                   muffleCondition(cond)
[17:28:41.959]                 })
[17:28:41.959]             }))
[17:28:41.959]             future::FutureResult(value = ...future.value$value, 
[17:28:41.959]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.959]                   ...future.rng), globalenv = if (FALSE) 
[17:28:41.959]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:41.959]                     ...future.globalenv.names))
[17:28:41.959]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:41.959]         }, condition = base::local({
[17:28:41.959]             c <- base::c
[17:28:41.959]             inherits <- base::inherits
[17:28:41.959]             invokeRestart <- base::invokeRestart
[17:28:41.959]             length <- base::length
[17:28:41.959]             list <- base::list
[17:28:41.959]             seq.int <- base::seq.int
[17:28:41.959]             signalCondition <- base::signalCondition
[17:28:41.959]             sys.calls <- base::sys.calls
[17:28:41.959]             `[[` <- base::`[[`
[17:28:41.959]             `+` <- base::`+`
[17:28:41.959]             `<<-` <- base::`<<-`
[17:28:41.959]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:41.959]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:41.959]                   3L)]
[17:28:41.959]             }
[17:28:41.959]             function(cond) {
[17:28:41.959]                 is_error <- inherits(cond, "error")
[17:28:41.959]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:41.959]                   NULL)
[17:28:41.959]                 if (is_error) {
[17:28:41.959]                   sessionInformation <- function() {
[17:28:41.959]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:41.959]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:41.959]                       search = base::search(), system = base::Sys.info())
[17:28:41.959]                   }
[17:28:41.959]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.959]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:41.959]                     cond$call), session = sessionInformation(), 
[17:28:41.959]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:41.959]                   signalCondition(cond)
[17:28:41.959]                 }
[17:28:41.959]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:41.959]                 "immediateCondition"))) {
[17:28:41.959]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:41.959]                   ...future.conditions[[length(...future.conditions) + 
[17:28:41.959]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:41.959]                   if (TRUE && !signal) {
[17:28:41.959]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.959]                     {
[17:28:41.959]                       inherits <- base::inherits
[17:28:41.959]                       invokeRestart <- base::invokeRestart
[17:28:41.959]                       is.null <- base::is.null
[17:28:41.959]                       muffled <- FALSE
[17:28:41.959]                       if (inherits(cond, "message")) {
[17:28:41.959]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.959]                         if (muffled) 
[17:28:41.959]                           invokeRestart("muffleMessage")
[17:28:41.959]                       }
[17:28:41.959]                       else if (inherits(cond, "warning")) {
[17:28:41.959]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.959]                         if (muffled) 
[17:28:41.959]                           invokeRestart("muffleWarning")
[17:28:41.959]                       }
[17:28:41.959]                       else if (inherits(cond, "condition")) {
[17:28:41.959]                         if (!is.null(pattern)) {
[17:28:41.959]                           computeRestarts <- base::computeRestarts
[17:28:41.959]                           grepl <- base::grepl
[17:28:41.959]                           restarts <- computeRestarts(cond)
[17:28:41.959]                           for (restart in restarts) {
[17:28:41.959]                             name <- restart$name
[17:28:41.959]                             if (is.null(name)) 
[17:28:41.959]                               next
[17:28:41.959]                             if (!grepl(pattern, name)) 
[17:28:41.959]                               next
[17:28:41.959]                             invokeRestart(restart)
[17:28:41.959]                             muffled <- TRUE
[17:28:41.959]                             break
[17:28:41.959]                           }
[17:28:41.959]                         }
[17:28:41.959]                       }
[17:28:41.959]                       invisible(muffled)
[17:28:41.959]                     }
[17:28:41.959]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.959]                   }
[17:28:41.959]                 }
[17:28:41.959]                 else {
[17:28:41.959]                   if (TRUE) {
[17:28:41.959]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:41.959]                     {
[17:28:41.959]                       inherits <- base::inherits
[17:28:41.959]                       invokeRestart <- base::invokeRestart
[17:28:41.959]                       is.null <- base::is.null
[17:28:41.959]                       muffled <- FALSE
[17:28:41.959]                       if (inherits(cond, "message")) {
[17:28:41.959]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:41.959]                         if (muffled) 
[17:28:41.959]                           invokeRestart("muffleMessage")
[17:28:41.959]                       }
[17:28:41.959]                       else if (inherits(cond, "warning")) {
[17:28:41.959]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:41.959]                         if (muffled) 
[17:28:41.959]                           invokeRestart("muffleWarning")
[17:28:41.959]                       }
[17:28:41.959]                       else if (inherits(cond, "condition")) {
[17:28:41.959]                         if (!is.null(pattern)) {
[17:28:41.959]                           computeRestarts <- base::computeRestarts
[17:28:41.959]                           grepl <- base::grepl
[17:28:41.959]                           restarts <- computeRestarts(cond)
[17:28:41.959]                           for (restart in restarts) {
[17:28:41.959]                             name <- restart$name
[17:28:41.959]                             if (is.null(name)) 
[17:28:41.959]                               next
[17:28:41.959]                             if (!grepl(pattern, name)) 
[17:28:41.959]                               next
[17:28:41.959]                             invokeRestart(restart)
[17:28:41.959]                             muffled <- TRUE
[17:28:41.959]                             break
[17:28:41.959]                           }
[17:28:41.959]                         }
[17:28:41.959]                       }
[17:28:41.959]                       invisible(muffled)
[17:28:41.959]                     }
[17:28:41.959]                     muffleCondition(cond, pattern = "^muffle")
[17:28:41.959]                   }
[17:28:41.959]                 }
[17:28:41.959]             }
[17:28:41.959]         }))
[17:28:41.959]     }, error = function(ex) {
[17:28:41.959]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:41.959]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:41.959]                 ...future.rng), started = ...future.startTime, 
[17:28:41.959]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:41.959]             version = "1.8"), class = "FutureResult")
[17:28:41.959]     }, finally = {
[17:28:41.959]         if (!identical(...future.workdir, getwd())) 
[17:28:41.959]             setwd(...future.workdir)
[17:28:41.959]         {
[17:28:41.959]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:41.959]                 ...future.oldOptions$nwarnings <- NULL
[17:28:41.959]             }
[17:28:41.959]             base::options(...future.oldOptions)
[17:28:41.959]             if (.Platform$OS.type == "windows") {
[17:28:41.959]                 old_names <- names(...future.oldEnvVars)
[17:28:41.959]                 envs <- base::Sys.getenv()
[17:28:41.959]                 names <- names(envs)
[17:28:41.959]                 common <- intersect(names, old_names)
[17:28:41.959]                 added <- setdiff(names, old_names)
[17:28:41.959]                 removed <- setdiff(old_names, names)
[17:28:41.959]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:41.959]                   envs[common]]
[17:28:41.959]                 NAMES <- toupper(changed)
[17:28:41.959]                 args <- list()
[17:28:41.959]                 for (kk in seq_along(NAMES)) {
[17:28:41.959]                   name <- changed[[kk]]
[17:28:41.959]                   NAME <- NAMES[[kk]]
[17:28:41.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.959]                     next
[17:28:41.959]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.959]                 }
[17:28:41.959]                 NAMES <- toupper(added)
[17:28:41.959]                 for (kk in seq_along(NAMES)) {
[17:28:41.959]                   name <- added[[kk]]
[17:28:41.959]                   NAME <- NAMES[[kk]]
[17:28:41.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.959]                     next
[17:28:41.959]                   args[[name]] <- ""
[17:28:41.959]                 }
[17:28:41.959]                 NAMES <- toupper(removed)
[17:28:41.959]                 for (kk in seq_along(NAMES)) {
[17:28:41.959]                   name <- removed[[kk]]
[17:28:41.959]                   NAME <- NAMES[[kk]]
[17:28:41.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:41.959]                     next
[17:28:41.959]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:41.959]                 }
[17:28:41.959]                 if (length(args) > 0) 
[17:28:41.959]                   base::do.call(base::Sys.setenv, args = args)
[17:28:41.959]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:41.959]             }
[17:28:41.959]             else {
[17:28:41.959]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:41.959]             }
[17:28:41.959]             {
[17:28:41.959]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:41.959]                   0L) {
[17:28:41.959]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:41.959]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:41.959]                   base::options(opts)
[17:28:41.959]                 }
[17:28:41.959]                 {
[17:28:41.959]                   {
[17:28:41.959]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:41.959]                     NULL
[17:28:41.959]                   }
[17:28:41.959]                   options(future.plan = NULL)
[17:28:41.959]                   if (is.na(NA_character_)) 
[17:28:41.959]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:41.959]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:41.959]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:41.959]                     .init = FALSE)
[17:28:41.959]                 }
[17:28:41.959]             }
[17:28:41.959]         }
[17:28:41.959]     })
[17:28:41.959]     if (TRUE) {
[17:28:41.959]         base::sink(type = "output", split = FALSE)
[17:28:41.959]         if (TRUE) {
[17:28:41.959]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:41.959]         }
[17:28:41.959]         else {
[17:28:41.959]             ...future.result["stdout"] <- base::list(NULL)
[17:28:41.959]         }
[17:28:41.959]         base::close(...future.stdout)
[17:28:41.959]         ...future.stdout <- NULL
[17:28:41.959]     }
[17:28:41.959]     ...future.result$conditions <- ...future.conditions
[17:28:41.959]     ...future.result$finished <- base::Sys.time()
[17:28:41.959]     ...future.result
[17:28:41.959] }
[17:28:41.965] Exporting 1 global objects (639 bytes) to cluster node #1 ...
[17:28:41.965] Exporting 'data' (356 bytes) to cluster node #1 ...
[17:28:41.965] Exporting 'data' (356 bytes) to cluster node #1 ... DONE
[17:28:41.966] Exporting 1 global objects (639 bytes) to cluster node #1 ... DONE
[17:28:41.966] MultisessionFuture started
[17:28:41.967] - Launch lazy future ... done
[17:28:41.967] run() for 'MultisessionFuture' ... done
[17:28:41.967] result() for ClusterFuture ...
[17:28:41.968] receiveMessageFromWorker() for ClusterFuture ...
[17:28:41.968] - Validating connection of MultisessionFuture
[17:28:42.005] - received message: FutureResult
[17:28:42.006] - Received FutureResult
[17:28:42.006] - Erased future from FutureRegistry
[17:28:42.007] result() for ClusterFuture ...
[17:28:42.007] - result already collected: FutureResult
[17:28:42.007] result() for ClusterFuture ... done
[17:28:42.008] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:42.008] result() for ClusterFuture ... done
[17:28:42.008] result() for ClusterFuture ...
[17:28:42.008] - result already collected: FutureResult
[17:28:42.008] result() for ClusterFuture ... done
- plan(list('multisession', 'multisession')) ... DONE
> 
> message("*** Nested futures ... DONE")
*** Nested futures ... DONE
> 
> source("incl/end.R")
[17:28:42.010] plan(): Setting new future strategy stack:
[17:28:42.010] List of future strategies:
[17:28:42.010] 1. FutureStrategy:
[17:28:42.010]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:42.010]    - tweaked: FALSE
[17:28:42.010]    - call: future::plan(oplan)
[17:28:42.021] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.73    0.18    3.56