R Under development (unstable) (2023-12-20 r85713 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

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

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

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

> source("incl/start.R")
[01:28:32.508] plan(): Setting new future strategy stack:
[01:28:32.510] List of future strategies:
[01:28:32.510] 1. sequential:
[01:28:32.510]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.510]    - tweaked: FALSE
[01:28:32.510]    - call: future::plan("sequential")
[01:28:32.529] 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')) ...
[01:28:32.598] plan(): Setting new future strategy stack:
[01:28:32.598] List of future strategies:
[01:28:32.598] 1. sequential:
[01:28:32.598]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.598]    - tweaked: FALSE
[01:28:32.598]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.598] 2. sequential:
[01:28:32.598]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.598]    - tweaked: FALSE
[01:28:32.598]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.613] plan(): nbrOfWorkers() = 1
[01:28:32.615] getGlobalsAndPackages() ...
[01:28:32.615] Searching for globals...
[01:28:32.645] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[01:28:32.646] Searching for globals ... DONE
[01:28:32.646] Resolving globals: FALSE
[01:28:32.648] The total size of the 2 globals is 22.60 KiB (23144 bytes)
[01:28:32.649] 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 22.60 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (22.48 KiB of class 'list') and 'strategy2' (120 bytes of class 'character')
[01:28:32.649] - globals: [2] 'nested', 'strategy2'
[01:28:32.649] - packages: [1] 'future'
[01:28:32.650] getGlobalsAndPackages() ... DONE
[01:28:32.650] run() for 'Future' ...
[01:28:32.651] - state: 'created'
[01:28:32.651] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:32.651] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:32.652] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:32.652]   - Field: 'label'
[01:28:32.652]   - Field: 'local'
[01:28:32.652]   - Field: 'owner'
[01:28:32.652]   - Field: 'envir'
[01:28:32.653]   - Field: 'packages'
[01:28:32.653]   - Field: 'gc'
[01:28:32.653]   - Field: 'conditions'
[01:28:32.653]   - Field: 'expr'
[01:28:32.653]   - Field: 'uuid'
[01:28:32.654]   - Field: 'seed'
[01:28:32.654]   - Field: 'version'
[01:28:32.654]   - Field: 'result'
[01:28:32.654]   - Field: 'asynchronous'
[01:28:32.654]   - Field: 'calls'
[01:28:32.654]   - Field: 'globals'
[01:28:32.655]   - Field: 'stdout'
[01:28:32.655]   - Field: 'earlySignal'
[01:28:32.655]   - Field: 'lazy'
[01:28:32.655]   - Field: 'state'
[01:28:32.655] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:32.655] - Launch lazy future ...
[01:28:32.656] Packages needed by the future expression (n = 1): 'future'
[01:28:32.657] Packages needed by future strategies (n = 1): 'future'
[01:28:32.658] {
[01:28:32.658]     {
[01:28:32.658]         {
[01:28:32.658]             ...future.startTime <- base::Sys.time()
[01:28:32.658]             {
[01:28:32.658]                 {
[01:28:32.658]                   {
[01:28:32.658]                     {
[01:28:32.658]                       base::local({
[01:28:32.658]                         has_future <- base::requireNamespace("future", 
[01:28:32.658]                           quietly = TRUE)
[01:28:32.658]                         if (has_future) {
[01:28:32.658]                           ns <- base::getNamespace("future")
[01:28:32.658]                           version <- ns[[".package"]][["version"]]
[01:28:32.658]                           if (is.null(version)) 
[01:28:32.658]                             version <- utils::packageVersion("future")
[01:28:32.658]                         }
[01:28:32.658]                         else {
[01:28:32.658]                           version <- NULL
[01:28:32.658]                         }
[01:28:32.658]                         if (!has_future || version < "1.8.0") {
[01:28:32.658]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:32.658]                             "", base::R.version$version.string), 
[01:28:32.658]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:32.658]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:32.658]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:32.658]                               "release", "version")], collapse = " "), 
[01:28:32.658]                             hostname = base::Sys.info()[["nodename"]])
[01:28:32.658]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:32.658]                             info)
[01:28:32.658]                           info <- base::paste(info, collapse = "; ")
[01:28:32.658]                           if (!has_future) {
[01:28:32.658]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:32.658]                               info)
[01:28:32.658]                           }
[01:28:32.658]                           else {
[01:28:32.658]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:32.658]                               info, version)
[01:28:32.658]                           }
[01:28:32.658]                           base::stop(msg)
[01:28:32.658]                         }
[01:28:32.658]                       })
[01:28:32.658]                     }
[01:28:32.658]                     base::local({
[01:28:32.658]                       for (pkg in "future") {
[01:28:32.658]                         base::loadNamespace(pkg)
[01:28:32.658]                         base::library(pkg, character.only = TRUE)
[01:28:32.658]                       }
[01:28:32.658]                     })
[01:28:32.658]                   }
[01:28:32.658]                   options(future.plan = NULL)
[01:28:32.658]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.658]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:32.658]                   {
[01:28:32.658]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.658]                     if (!future$lazy) 
[01:28:32.658]                       future <- run(future)
[01:28:32.658]                     invisible(future)
[01:28:32.658]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.658]                 }
[01:28:32.658]                 ...future.workdir <- getwd()
[01:28:32.658]             }
[01:28:32.658]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:32.658]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:32.658]         }
[01:28:32.658]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:32.658]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:32.658]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:32.658]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:32.658]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:32.658]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:32.658]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:32.658]             base::names(...future.oldOptions))
[01:28:32.658]     }
[01:28:32.658]     if (FALSE) {
[01:28:32.658]     }
[01:28:32.658]     else {
[01:28:32.658]         if (TRUE) {
[01:28:32.658]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:32.658]                 open = "w")
[01:28:32.658]         }
[01:28:32.658]         else {
[01:28:32.658]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:32.658]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:32.658]         }
[01:28:32.658]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:32.658]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:32.658]             base::sink(type = "output", split = FALSE)
[01:28:32.658]             base::close(...future.stdout)
[01:28:32.658]         }, add = TRUE)
[01:28:32.658]     }
[01:28:32.658]     ...future.frame <- base::sys.nframe()
[01:28:32.658]     ...future.conditions <- base::list()
[01:28:32.658]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:32.658]     if (FALSE) {
[01:28:32.658]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:32.658]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:32.658]     }
[01:28:32.658]     ...future.result <- base::tryCatch({
[01:28:32.658]         base::withCallingHandlers({
[01:28:32.658]             ...future.value <- base::withVisible(base::local({
[01:28:32.658]                 a <- 1L
[01:28:32.658]                 plan_a <- unclass(future::plan("list"))
[01:28:32.658]                 nested_a <- nested[-1]
[01:28:32.658]                 stopifnot(length(nested_a) == 1L, length(plan_a) == 
[01:28:32.658]                   1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[01:28:32.658]                   strategy2))
[01:28:32.658]                 for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[01:28:32.658]                   "init") <- NULL
[01:28:32.658]                 for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[01:28:32.658]                   "init") <- NULL
[01:28:32.658]                 stopifnot(all.equal(plan_a, nested_a))
[01:28:32.658]                 y %<-% {
[01:28:32.658]                   b <- 2L
[01:28:32.658]                   plan_b <- future::plan("list")
[01:28:32.658]                   nested_b <- nested_a[-1]
[01:28:32.658]                   stopifnot(length(nested_b) == 0L, length(plan_b) == 
[01:28:32.658]                     1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[01:28:32.658]                     "sequential"))
[01:28:32.658]                   list(a = a, nested_a = nested_a, plan_a = plan_a, 
[01:28:32.658]                     b = b, nested_b = nested_b, plan_b = plan_b)
[01:28:32.658]                 }
[01:28:32.658]                 y
[01:28:32.658]             }))
[01:28:32.658]             future::FutureResult(value = ...future.value$value, 
[01:28:32.658]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.658]                   ...future.rng), globalenv = if (FALSE) 
[01:28:32.658]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:32.658]                     ...future.globalenv.names))
[01:28:32.658]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:32.658]         }, condition = base::local({
[01:28:32.658]             c <- base::c
[01:28:32.658]             inherits <- base::inherits
[01:28:32.658]             invokeRestart <- base::invokeRestart
[01:28:32.658]             length <- base::length
[01:28:32.658]             list <- base::list
[01:28:32.658]             seq.int <- base::seq.int
[01:28:32.658]             signalCondition <- base::signalCondition
[01:28:32.658]             sys.calls <- base::sys.calls
[01:28:32.658]             `[[` <- base::`[[`
[01:28:32.658]             `+` <- base::`+`
[01:28:32.658]             `<<-` <- base::`<<-`
[01:28:32.658]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:32.658]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:32.658]                   3L)]
[01:28:32.658]             }
[01:28:32.658]             function(cond) {
[01:28:32.658]                 is_error <- inherits(cond, "error")
[01:28:32.658]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:32.658]                   NULL)
[01:28:32.658]                 if (is_error) {
[01:28:32.658]                   sessionInformation <- function() {
[01:28:32.658]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:32.658]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:32.658]                       search = base::search(), system = base::Sys.info())
[01:28:32.658]                   }
[01:28:32.658]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.658]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:32.658]                     cond$call), session = sessionInformation(), 
[01:28:32.658]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:32.658]                   signalCondition(cond)
[01:28:32.658]                 }
[01:28:32.658]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:32.658]                 "immediateCondition"))) {
[01:28:32.658]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:32.658]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.658]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:32.658]                   if (TRUE && !signal) {
[01:28:32.658]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.658]                     {
[01:28:32.658]                       inherits <- base::inherits
[01:28:32.658]                       invokeRestart <- base::invokeRestart
[01:28:32.658]                       is.null <- base::is.null
[01:28:32.658]                       muffled <- FALSE
[01:28:32.658]                       if (inherits(cond, "message")) {
[01:28:32.658]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.658]                         if (muffled) 
[01:28:32.658]                           invokeRestart("muffleMessage")
[01:28:32.658]                       }
[01:28:32.658]                       else if (inherits(cond, "warning")) {
[01:28:32.658]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.658]                         if (muffled) 
[01:28:32.658]                           invokeRestart("muffleWarning")
[01:28:32.658]                       }
[01:28:32.658]                       else if (inherits(cond, "condition")) {
[01:28:32.658]                         if (!is.null(pattern)) {
[01:28:32.658]                           computeRestarts <- base::computeRestarts
[01:28:32.658]                           grepl <- base::grepl
[01:28:32.658]                           restarts <- computeRestarts(cond)
[01:28:32.658]                           for (restart in restarts) {
[01:28:32.658]                             name <- restart$name
[01:28:32.658]                             if (is.null(name)) 
[01:28:32.658]                               next
[01:28:32.658]                             if (!grepl(pattern, name)) 
[01:28:32.658]                               next
[01:28:32.658]                             invokeRestart(restart)
[01:28:32.658]                             muffled <- TRUE
[01:28:32.658]                             break
[01:28:32.658]                           }
[01:28:32.658]                         }
[01:28:32.658]                       }
[01:28:32.658]                       invisible(muffled)
[01:28:32.658]                     }
[01:28:32.658]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.658]                   }
[01:28:32.658]                 }
[01:28:32.658]                 else {
[01:28:32.658]                   if (TRUE) {
[01:28:32.658]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.658]                     {
[01:28:32.658]                       inherits <- base::inherits
[01:28:32.658]                       invokeRestart <- base::invokeRestart
[01:28:32.658]                       is.null <- base::is.null
[01:28:32.658]                       muffled <- FALSE
[01:28:32.658]                       if (inherits(cond, "message")) {
[01:28:32.658]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.658]                         if (muffled) 
[01:28:32.658]                           invokeRestart("muffleMessage")
[01:28:32.658]                       }
[01:28:32.658]                       else if (inherits(cond, "warning")) {
[01:28:32.658]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.658]                         if (muffled) 
[01:28:32.658]                           invokeRestart("muffleWarning")
[01:28:32.658]                       }
[01:28:32.658]                       else if (inherits(cond, "condition")) {
[01:28:32.658]                         if (!is.null(pattern)) {
[01:28:32.658]                           computeRestarts <- base::computeRestarts
[01:28:32.658]                           grepl <- base::grepl
[01:28:32.658]                           restarts <- computeRestarts(cond)
[01:28:32.658]                           for (restart in restarts) {
[01:28:32.658]                             name <- restart$name
[01:28:32.658]                             if (is.null(name)) 
[01:28:32.658]                               next
[01:28:32.658]                             if (!grepl(pattern, name)) 
[01:28:32.658]                               next
[01:28:32.658]                             invokeRestart(restart)
[01:28:32.658]                             muffled <- TRUE
[01:28:32.658]                             break
[01:28:32.658]                           }
[01:28:32.658]                         }
[01:28:32.658]                       }
[01:28:32.658]                       invisible(muffled)
[01:28:32.658]                     }
[01:28:32.658]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.658]                   }
[01:28:32.658]                 }
[01:28:32.658]             }
[01:28:32.658]         }))
[01:28:32.658]     }, error = function(ex) {
[01:28:32.658]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:32.658]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.658]                 ...future.rng), started = ...future.startTime, 
[01:28:32.658]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:32.658]             version = "1.8"), class = "FutureResult")
[01:28:32.658]     }, finally = {
[01:28:32.658]         if (!identical(...future.workdir, getwd())) 
[01:28:32.658]             setwd(...future.workdir)
[01:28:32.658]         {
[01:28:32.658]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:32.658]                 ...future.oldOptions$nwarnings <- NULL
[01:28:32.658]             }
[01:28:32.658]             base::options(...future.oldOptions)
[01:28:32.658]             if (.Platform$OS.type == "windows") {
[01:28:32.658]                 old_names <- names(...future.oldEnvVars)
[01:28:32.658]                 envs <- base::Sys.getenv()
[01:28:32.658]                 names <- names(envs)
[01:28:32.658]                 common <- intersect(names, old_names)
[01:28:32.658]                 added <- setdiff(names, old_names)
[01:28:32.658]                 removed <- setdiff(old_names, names)
[01:28:32.658]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:32.658]                   envs[common]]
[01:28:32.658]                 NAMES <- toupper(changed)
[01:28:32.658]                 args <- list()
[01:28:32.658]                 for (kk in seq_along(NAMES)) {
[01:28:32.658]                   name <- changed[[kk]]
[01:28:32.658]                   NAME <- NAMES[[kk]]
[01:28:32.658]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.658]                     next
[01:28:32.658]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.658]                 }
[01:28:32.658]                 NAMES <- toupper(added)
[01:28:32.658]                 for (kk in seq_along(NAMES)) {
[01:28:32.658]                   name <- added[[kk]]
[01:28:32.658]                   NAME <- NAMES[[kk]]
[01:28:32.658]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.658]                     next
[01:28:32.658]                   args[[name]] <- ""
[01:28:32.658]                 }
[01:28:32.658]                 NAMES <- toupper(removed)
[01:28:32.658]                 for (kk in seq_along(NAMES)) {
[01:28:32.658]                   name <- removed[[kk]]
[01:28:32.658]                   NAME <- NAMES[[kk]]
[01:28:32.658]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.658]                     next
[01:28:32.658]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.658]                 }
[01:28:32.658]                 if (length(args) > 0) 
[01:28:32.658]                   base::do.call(base::Sys.setenv, args = args)
[01:28:32.658]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:32.658]             }
[01:28:32.658]             else {
[01:28:32.658]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:32.658]             }
[01:28:32.658]             {
[01:28:32.658]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:32.658]                   0L) {
[01:28:32.658]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:32.658]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:32.658]                   base::options(opts)
[01:28:32.658]                 }
[01:28:32.658]                 {
[01:28:32.658]                   {
[01:28:32.658]                     NULL
[01:28:32.658]                     RNGkind("Mersenne-Twister")
[01:28:32.658]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:32.658]                       inherits = FALSE)
[01:28:32.658]                   }
[01:28:32.658]                   options(future.plan = NULL)
[01:28:32.658]                   if (is.na(NA_character_)) 
[01:28:32.658]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.658]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:32.658]                   future::plan(list(a = function (..., envir = parent.frame()) 
[01:28:32.658]                   {
[01:28:32.658]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.658]                     if (!future$lazy) 
[01:28:32.658]                       future <- run(future)
[01:28:32.658]                     invisible(future)
[01:28:32.658]                   }, b = function (..., envir = parent.frame()) 
[01:28:32.658]                   {
[01:28:32.658]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.658]                     if (!future$lazy) 
[01:28:32.658]                       future <- run(future)
[01:28:32.658]                     invisible(future)
[01:28:32.658]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.658]                 }
[01:28:32.658]             }
[01:28:32.658]         }
[01:28:32.658]     })
[01:28:32.658]     if (TRUE) {
[01:28:32.658]         base::sink(type = "output", split = FALSE)
[01:28:32.658]         if (TRUE) {
[01:28:32.658]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:32.658]         }
[01:28:32.658]         else {
[01:28:32.658]             ...future.result["stdout"] <- base::list(NULL)
[01:28:32.658]         }
[01:28:32.658]         base::close(...future.stdout)
[01:28:32.658]         ...future.stdout <- NULL
[01:28:32.658]     }
[01:28:32.658]     ...future.result$conditions <- ...future.conditions
[01:28:32.658]     ...future.result$finished <- base::Sys.time()
[01:28:32.658]     ...future.result
[01:28:32.658] }
[01:28:32.663] assign_globals() ...
[01:28:32.663] List of 2
[01:28:32.663]  $ nested   :List of 2
[01:28:32.663]   ..$ a:function (..., envir = parent.frame())  
[01:28:32.663]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[01:28:32.663]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[01:28:32.663]   ..$ b:function (..., envir = parent.frame())  
[01:28:32.663]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[01:28:32.663]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[01:28:32.663]   ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[01:28:32.663]  $ strategy2: chr "sequential"
[01:28:32.663]  - attr(*, "where")=List of 2
[01:28:32.663]   ..$ nested   :<environment: R_EmptyEnv> 
[01:28:32.663]   ..$ strategy2:<environment: R_EmptyEnv> 
[01:28:32.663]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:32.663]  - attr(*, "resolved")= logi FALSE
[01:28:32.663]  - attr(*, "total_size")= num 23144
[01:28:32.663]  - attr(*, "already-done")= logi TRUE
[01:28:32.672] - copied 'nested' to environment
[01:28:32.672] - copied 'strategy2' to environment
[01:28:32.672] assign_globals() ... done
[01:28:32.673] plan(): Setting new future strategy stack:
[01:28:32.673] List of future strategies:
[01:28:32.673] 1. sequential:
[01:28:32.673]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.673]    - tweaked: FALSE
[01:28:32.673]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.674] plan(): nbrOfWorkers() = 1
[01:28:32.746] plan(): Setting new future strategy stack:
[01:28:32.746] List of future strategies:
[01:28:32.746] 1. sequential:
[01:28:32.746]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.746]    - tweaked: FALSE
[01:28:32.746]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.746] 2. sequential:
[01:28:32.746]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.746]    - tweaked: FALSE
[01:28:32.746]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.747] plan(): nbrOfWorkers() = 1
[01:28:32.748] SequentialFuture started (and completed)
[01:28:32.748] signalConditions() ...
[01:28:32.748]  - include = 'immediateCondition'
[01:28:32.749]  - exclude = 
[01:28:32.749]  - resignal = FALSE
[01:28:32.749]  - Number of conditions: 54
[01:28:32.749] signalConditions() ... done
[01:28:32.749] - Launch lazy future ... done
[01:28:32.750] run() for 'SequentialFuture' ... done
[01:28:32.750] signalConditions() ...
[01:28:32.750]  - include = 'immediateCondition'
[01:28:32.750]  - exclude = 
[01:28:32.751]  - resignal = FALSE
[01:28:32.751]  - Number of conditions: 54
[01:28:32.751] signalConditions() ... done
[01:28:32.751] Future state: 'finished'
[01:28:32.751] signalConditions() ...
[01:28:32.752]  - include = 'condition'
[01:28:32.752]  - exclude = 'immediateCondition'
[01:28:32.752]  - resignal = TRUE
[01:28:32.752]  - Number of conditions: 54
[01:28:32.752]  - Condition #1: 'simpleMessage', 'message', 'condition'
[01:28:32.676] getGlobalsAndPackages() ...
[01:28:32.753]  - Condition #2: 'simpleMessage', 'message', 'condition'
[01:28:32.676] Searching for globals...
[01:28:32.753]  - Condition #3: 'simpleMessage', 'message', 'condition'
[01:28:32.700] - globals found: [14] '{', '<-', '::', '[', 'nested_a', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'list', 'a', 'plan_a'
[01:28:32.753]  - Condition #4: 'simpleMessage', 'message', 'condition'
[01:28:32.701] Searching for globals ... DONE
[01:28:32.754]  - Condition #5: 'simpleMessage', 'message', 'condition'
[01:28:32.701] Resolving globals: FALSE
[01:28:32.754]  - Condition #6: 'simpleMessage', 'message', 'condition'
[01:28:32.703] The total size of the 3 globals is 22.54 KiB (23080 bytes)
[01:28:32.754]  - Condition #7: 'simpleMessage', 'message', 'condition'
[01:28:32.704] 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 22.54 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'nested_a' (11.24 KiB of class 'list'), 'plan_a' (11.24 KiB of class 'list') and 'a' (56 bytes of class 'numeric')
[01:28:32.754]  - Condition #8: 'simpleMessage', 'message', 'condition'
[01:28:32.710] - globals: [3] 'nested_a', 'a', 'plan_a'
[01:28:32.755]  - Condition #9: 'simpleMessage', 'message', 'condition'
[01:28:32.710] 
[01:28:32.755]  - Condition #10: 'simpleMessage', 'message', 'condition'
[01:28:32.710] getGlobalsAndPackages() ... DONE
[01:28:32.755]  - Condition #11: 'simpleMessage', 'message', 'condition'
[01:28:32.711] run() for 'Future' ...
[01:28:32.755]  - Condition #12: 'simpleMessage', 'message', 'condition'
[01:28:32.711] - state: 'created'
[01:28:32.756]  - Condition #13: 'simpleMessage', 'message', 'condition'
[01:28:32.712] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:32.756]  - Condition #14: 'simpleMessage', 'message', 'condition'
[01:28:32.713] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:32.759]  - Condition #15: 'simpleMessage', 'message', 'condition'
[01:28:32.713] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:32.760]  - Condition #16: 'simpleMessage', 'message', 'condition'
[01:28:32.713]   - Field: 'label'
[01:28:32.760]  - Condition #17: 'simpleMessage', 'message', 'condition'
[01:28:32.714]   - Field: 'local'
[01:28:32.760]  - Condition #18: 'simpleMessage', 'message', 'condition'
[01:28:32.714]   - Field: 'owner'
[01:28:32.760]  - Condition #19: 'simpleMessage', 'message', 'condition'
[01:28:32.714]   - Field: 'envir'
[01:28:32.761]  - Condition #20: 'simpleMessage', 'message', 'condition'
[01:28:32.714]   - Field: 'packages'
[01:28:32.761]  - Condition #21: 'simpleMessage', 'message', 'condition'
[01:28:32.715]   - Field: 'gc'
[01:28:32.761]  - Condition #22: 'simpleMessage', 'message', 'condition'
[01:28:32.715]   - Field: 'conditions'
[01:28:32.761]  - Condition #23: 'simpleMessage', 'message', 'condition'
[01:28:32.715]   - Field: 'expr'
[01:28:32.762]  - Condition #24: 'simpleMessage', 'message', 'condition'
[01:28:32.716]   - Field: 'uuid'
[01:28:32.762]  - Condition #25: 'simpleMessage', 'message', 'condition'
[01:28:32.716]   - Field: 'seed'
[01:28:32.762]  - Condition #26: 'simpleMessage', 'message', 'condition'
[01:28:32.716]   - Field: 'version'
[01:28:32.762]  - Condition #27: 'simpleMessage', 'message', 'condition'
[01:28:32.716]   - Field: 'result'
[01:28:32.763]  - Condition #28: 'simpleMessage', 'message', 'condition'
[01:28:32.717]   - Field: 'asynchronous'
[01:28:32.763]  - Condition #29: 'simpleMessage', 'message', 'condition'
[01:28:32.717]   - Field: 'calls'
[01:28:32.763]  - Condition #30: 'simpleMessage', 'message', 'condition'
[01:28:32.717]   - Field: 'globals'
[01:28:32.763]  - Condition #31: 'simpleMessage', 'message', 'condition'
[01:28:32.717]   - Field: 'stdout'
[01:28:32.764]  - Condition #32: 'simpleMessage', 'message', 'condition'
[01:28:32.718]   - Field: 'earlySignal'
[01:28:32.764]  - Condition #33: 'simpleMessage', 'message', 'condition'
[01:28:32.718]   - Field: 'lazy'
[01:28:32.764]  - Condition #34: 'simpleMessage', 'message', 'condition'
[01:28:32.718]   - Field: 'state'
[01:28:32.764]  - Condition #35: 'simpleMessage', 'message', 'condition'
[01:28:32.718] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:32.765]  - Condition #36: 'simpleMessage', 'message', 'condition'
[01:28:32.719] - Launch lazy future ...
[01:28:32.765]  - Condition #37: 'simpleMessage', 'message', 'condition'
[01:28:32.719] Packages needed by the future expression (n = 0): <none>
[01:28:32.765]  - Condition #38: 'simpleMessage', 'message', 'condition'
[01:28:32.720] Packages needed by future strategies (n = 0): <none>
[01:28:32.765]  - Condition #39: 'simpleMessage', 'message', 'condition'
[01:28:32.721] {
[01:28:32.721]     {
[01:28:32.721]         {
[01:28:32.721]             ...future.startTime <- base::Sys.time()
[01:28:32.721]             {
[01:28:32.721]                 {
[01:28:32.721]                   {
[01:28:32.721]                     base::local({
[01:28:32.721]                       has_future <- base::requireNamespace("future", 
[01:28:32.721]                         quietly = TRUE)
[01:28:32.721]                       if (has_future) {
[01:28:32.721]                         ns <- base::getNamespace("future")
[01:28:32.721]                         version <- ns[[".package"]][["version"]]
[01:28:32.721]                         if (is.null(version)) 
[01:28:32.721]                           version <- utils::packageVersion("future")
[01:28:32.721]                       }
[01:28:32.721]                       else {
[01:28:32.721]                         version <- NULL
[01:28:32.721]                       }
[01:28:32.721]                       if (!has_future || version < "1.8.0") {
[01:28:32.721]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:32.721]                           "", base::R.version$version.string), 
[01:28:32.721]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:32.721]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:32.721]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:32.721]                             "release", "version")], collapse = " "), 
[01:28:32.721]                           hostname = base::Sys.info()[["nodename"]])
[01:28:32.721]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:32.721]                           info)
[01:28:32.721]                         info <- base::paste(info, collapse = "; ")
[01:28:32.721]                         if (!has_future) {
[01:28:32.721]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:32.721]                             info)
[01:28:32.721]                         }
[01:28:32.721]                         else {
[01:28:32.721]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:32.721]                             info, version)
[01:28:32.721]                         }
[01:28:32.721]                         base::stop(msg)
[01:28:32.721]                       }
[01:28:32.721]                     })
[01:28:32.721]                   }
[01:28:32.721]                   options(future.plan = NULL)
[01:28:32.721]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.721]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:32.721]                 }
[01:28:32.721]                 ...future.workdir <- getwd()
[01:28:32.721]             }
[01:28:32.721]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:32.721]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:32.721]         }
[01:28:32.721]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:32.721]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:32.721]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:32.721]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:32.721]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:32.721]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:32.721]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:32.721]             base::names(...future.oldOptions))
[01:28:32.721]     }
[01:28:32.721]     if (FALSE) {
[01:28:32.721]     }
[01:28:32.721]     else {
[01:28:32.721]         if (TRUE) {
[01:28:32.721]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:32.721]                 open = "w")
[01:28:32.721]         }
[01:28:32.721]         else {
[01:28:32.721]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:32.721]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:32.721]         }
[01:28:32.721]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:32.721]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:32.721]             base::sink(type = "output", split = FALSE)
[01:28:32.721]             base::close(...future.stdout)
[01:28:32.721]         }, add = TRUE)
[01:28:32.721]     }
[01:28:32.721]     ...future.frame <- base::sys.nframe()
[01:28:32.721]     ...future.conditions <- base::list()
[01:28:32.721]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:32.721]     if (FALSE) {
[01:28:32.721]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:32.721]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:32.721]     }
[01:28:32.721]     ...future.result <- base::tryCatch({
[01:28:32.721]         base::withCallingHandlers({
[01:28:32.721]             ...future.value <- base::withVisible(base::local({
[01:28:32.721]                 b <- 2L
[01:28:32.721]                 plan_b <- future::plan("list")
[01:28:32.721]                 nested_b <- nested_a[-1]
[01:28:32.721]                 stopifnot(length(nested_b) == 0L, length(plan_b) == 
[01:28:32.721]                   1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[01:28:32.721]                   "sequential"))
[01:28:32.721]                 list(a = a, nested_a = nested_a, plan_a = plan_a, 
[01:28:32.721]                   b = b, nested_b = nested_b, plan_b = plan_b)
[01:28:32.721]             }))
[01:28:32.721]             future::FutureResult(value = ...future.value$value, 
[01:28:32.721]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.721]                   ...future.rng), globalenv = if (FALSE) 
[01:28:32.721]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:32.721]                     ...future.globalenv.names))
[01:28:32.721]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:32.721]         }, condition = base::local({
[01:28:32.721]             c <- base::c
[01:28:32.721]             inherits <- base::inherits
[01:28:32.721]             invokeRestart <- base::invokeRestart
[01:28:32.721]             length <- base::length
[01:28:32.721]             list <- base::list
[01:28:32.721]             seq.int <- base::seq.int
[01:28:32.721]             signalCondition <- base::signalCondition
[01:28:32.721]             sys.calls <- base::sys.calls
[01:28:32.721]             `[[` <- base::`[[`
[01:28:32.721]             `+` <- base::`+`
[01:28:32.721]             `<<-` <- base::`<<-`
[01:28:32.721]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:32.721]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:32.721]                   3L)]
[01:28:32.721]             }
[01:28:32.721]             function(cond) {
[01:28:32.721]                 is_error <- inherits(cond, "error")
[01:28:32.721]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:32.721]                   NULL)
[01:28:32.721]                 if (is_error) {
[01:28:32.721]                   sessionInformation <- function() {
[01:28:32.721]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:32.721]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:32.721]                       search = base::search(), system = base::Sys.info())
[01:28:32.721]                   }
[01:28:32.721]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.721]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:32.721]                     cond$call), session = sessionInformation(), 
[01:28:32.721]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:32.721]                   signalCondition(cond)
[01:28:32.721]                 }
[01:28:32.721]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:32.721]                 "immediateCondition"))) {
[01:28:32.721]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:32.721]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.721]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:32.721]                   if (TRUE && !signal) {
[01:28:32.721]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.721]                     {
[01:28:32.721]                       inherits <- base::inherits
[01:28:32.721]                       invokeRestart <- base::invokeRestart
[01:28:32.721]                       is.null <- base::is.null
[01:28:32.721]                       muffled <- FALSE
[01:28:32.721]                       if (inherits(cond, "message")) {
[01:28:32.721]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.721]                         if (muffled) 
[01:28:32.721]                           invokeRestart("muffleMessage")
[01:28:32.721]                       }
[01:28:32.721]                       else if (inherits(cond, "warning")) {
[01:28:32.721]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.721]                         if (muffled) 
[01:28:32.721]                           invokeRestart("muffleWarning")
[01:28:32.721]                       }
[01:28:32.721]                       else if (inherits(cond, "condition")) {
[01:28:32.721]                         if (!is.null(pattern)) {
[01:28:32.721]                           computeRestarts <- base::computeRestarts
[01:28:32.721]                           grepl <- base::grepl
[01:28:32.721]                           restarts <- computeRestarts(cond)
[01:28:32.721]                           for (restart in restarts) {
[01:28:32.721]                             name <- restart$name
[01:28:32.721]                             if (is.null(name)) 
[01:28:32.721]                               next
[01:28:32.721]                             if (!grepl(pattern, name)) 
[01:28:32.721]                               next
[01:28:32.721]                             invokeRestart(restart)
[01:28:32.721]                             muffled <- TRUE
[01:28:32.721]                             break
[01:28:32.721]                           }
[01:28:32.721]                         }
[01:28:32.721]                       }
[01:28:32.721]                       invisible(muffled)
[01:28:32.721]                     }
[01:28:32.721]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.721]                   }
[01:28:32.721]                 }
[01:28:32.721]                 else {
[01:28:32.721]                   if (TRUE) {
[01:28:32.721]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.721]                     {
[01:28:32.721]                       inherits <- base::inherits
[01:28:32.721]                       invokeRestart <- base::invokeRestart
[01:28:32.721]                       is.null <- base::is.null
[01:28:32.721]                       muffled <- FALSE
[01:28:32.721]                       if (inherits(cond, "message")) {
[01:28:32.721]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.721]                         if (muffled) 
[01:28:32.721]                           invokeRestart("muffleMessage")
[01:28:32.721]                       }
[01:28:32.721]                       else if (inherits(cond, "warning")) {
[01:28:32.721]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.721]                         if (muffled) 
[01:28:32.721]                           invokeRestart("muffleWarning")
[01:28:32.721]                       }
[01:28:32.721]                       else if (inherits(cond, "condition")) {
[01:28:32.721]                         if (!is.null(pattern)) {
[01:28:32.721]                           computeRestarts <- base::computeRestarts
[01:28:32.721]                           grepl <- base::grepl
[01:28:32.721]                           restarts <- computeRestarts(cond)
[01:28:32.721]                           for (restart in restarts) {
[01:28:32.721]                             name <- restart$name
[01:28:32.721]                             if (is.null(name)) 
[01:28:32.721]                               next
[01:28:32.721]                             if (!grepl(pattern, name)) 
[01:28:32.721]                               next
[01:28:32.721]                             invokeRestart(restart)
[01:28:32.721]                             muffled <- TRUE
[01:28:32.721]                             break
[01:28:32.721]                           }
[01:28:32.721]                         }
[01:28:32.721]                       }
[01:28:32.721]                       invisible(muffled)
[01:28:32.721]                     }
[01:28:32.721]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.721]                   }
[01:28:32.721]                 }
[01:28:32.721]             }
[01:28:32.721]         }))
[01:28:32.721]     }, error = function(ex) {
[01:28:32.721]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:32.721]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.721]                 ...future.rng), started = ...future.startTime, 
[01:28:32.721]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:32.721]             version = "1.8"), class = "FutureResult")
[01:28:32.721]     }, finally = {
[01:28:32.721]         if (!identical(...future.workdir, getwd())) 
[01:28:32.721]             setwd(...future.workdir)
[01:28:32.721]         {
[01:28:32.721]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:32.721]                 ...future.oldOptions$nwarnings <- NULL
[01:28:32.721]             }
[01:28:32.721]             base::options(...future.oldOptions)
[01:28:32.721]             if (.Platform$OS.type == "windows") {
[01:28:32.721]                 old_names <- names(...future.oldEnvVars)
[01:28:32.721]                 envs <- base::Sys.getenv()
[01:28:32.721]                 names <- names(envs)
[01:28:32.721]                 common <- intersect(names, old_names)
[01:28:32.721]                 added <- setdiff(names, old_names)
[01:28:32.721]                 removed <- setdiff(old_names, names)
[01:28:32.721]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:32.721]                   envs[common]]
[01:28:32.721]                 NAMES <- toupper(changed)
[01:28:32.721]                 args <- list()
[01:28:32.721]                 for (kk in seq_along(NAMES)) {
[01:28:32.721]                   name <- changed[[kk]]
[01:28:32.721]                   NAME <- NAMES[[kk]]
[01:28:32.721]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.721]                     next
[01:28:32.721]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.721]                 }
[01:28:32.721]                 NAMES <- toupper(added)
[01:28:32.721]                 for (kk in seq_along(NAMES)) {
[01:28:32.721]                   name <- added[[kk]]
[01:28:32.721]                   NAME <- NAMES[[kk]]
[01:28:32.721]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.721]                     next
[01:28:32.721]                   args[[name]] <- ""
[01:28:32.721]                 }
[01:28:32.721]                 NAMES <- toupper(removed)
[01:28:32.721]                 for (kk in seq_along(NAMES)) {
[01:28:32.721]                   name <- removed[[kk]]
[01:28:32.721]                   NAME <- NAMES[[kk]]
[01:28:32.721]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.721]                     next
[01:28:32.721]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.721]                 }
[01:28:32.721]                 if (length(args) > 0) 
[01:28:32.721]                   base::do.call(base::Sys.setenv, args = args)
[01:28:32.721]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:32.721]             }
[01:28:32.721]             else {
[01:28:32.721]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:32.721]             }
[01:28:32.721]             {
[01:28:32.721]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:32.721]                   0L) {
[01:28:32.721]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:32.721]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:32.721]                   base::options(opts)
[01:28:32.721]                 }
[01:28:32.721]                 {
[01:28:32.721]                   {
[01:28:32.721]                     NULL
[01:28:32.721]                     RNGkind("Mersenne-Twister")
[01:28:32.721]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:32.721]                       inherits = FALSE)
[01:28:32.721]                   }
[01:28:32.721]                   options(future.plan = NULL)
[01:28:32.721]                   if (is.na(NA_character_)) 
[01:28:32.721]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.721]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:32.721]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:32.721]                   {
[01:28:32.721]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.721]                     if (!future$lazy) 
[01:28:32.721]                       future <- run(future)
[01:28:32.721]                     invisible(future)
[01:28:32.721]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.721]                 }
[01:28:32.721]             }
[01:28:32.721]         }
[01:28:32.721]     })
[01:28:32.721]     if (TRUE) {
[01:28:32.721]         base::sink(type = "output", split = FALSE)
[01:28:32.721]         if (TRUE) {
[01:28:32.721]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:32.721]         }
[01:28:32.721]         else {
[01:28:32.721]             ...future.result["stdout"] <- base::list(NULL)
[01:28:32.721]         }
[01:28:32.721]         base::close(...future.stdout)
[01:28:32.721]         ...future.stdout <- NULL
[01:28:32.721]     }
[01:28:32.721]     ...future.result$conditions <- ...future.conditions
[01:28:32.721]     ...future.result$finished <- base::Sys.time()
[01:28:32.721]     ...future.result
[01:28:32.721] }
[01:28:32.766]  - Condition #40: 'simpleMessage', 'message', 'condition'
[01:28:32.725] assign_globals() ...
[01:28:32.766]  - Condition #41: 'simpleMessage', 'message', 'condition'
[01:28:32.726] List of 3
[01:28:32.726]  $ nested_a:List of 1
[01:28:32.726]   ..$ b:function (..., envir = parent.frame())  
[01:28:32.726]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[01:28:32.726]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[01:28:32.726]  $ a       : int 1
[01:28:32.726]  $ plan_a  :List of 1
[01:28:32.726]   ..$ b:function (..., envir = parent.frame())  
[01:28:32.726]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[01:28:32.726]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[01:28:32.726]  - attr(*, "where")=List of 3
[01:28:32.726]   ..$ nested_a:<environment: R_EmptyEnv> 
[01:28:32.726]   ..$ a       :<environment: R_EmptyEnv> 
[01:28:32.726]   ..$ plan_a  :<environment: R_EmptyEnv> 
[01:28:32.726]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:32.726]  - attr(*, "resolved")= logi FALSE
[01:28:32.726]  - attr(*, "total_size")= num 23080
[01:28:32.726]  - attr(*, "already-done")= logi TRUE
[01:28:32.766]  - Condition #42: 'simpleMessage', 'message', 'condition'
[01:28:32.736] - copied 'nested_a' to environment
[01:28:32.767]  - Condition #43: 'simpleMessage', 'message', 'condition'
[01:28:32.736] - copied 'a' to environment
[01:28:32.767]  - Condition #44: 'simpleMessage', 'message', 'condition'
[01:28:32.736] - copied 'plan_a' to environment
[01:28:32.767]  - Condition #45: 'simpleMessage', 'message', 'condition'
[01:28:32.737] assign_globals() ... done
[01:28:32.767]  - Condition #46: 'simpleMessage', 'message', 'condition'
[01:28:32.737] plan(): Setting new future strategy stack:
[01:28:32.767]  - Condition #47: 'simpleMessage', 'message', 'condition'
[01:28:32.738] List of future strategies:
[01:28:32.738] 1. sequential:
[01:28:32.738]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.738]    - tweaked: FALSE
[01:28:32.738]    - call: NULL
[01:28:32.768]  - Condition #48: 'simpleMessage', 'message', 'condition'
[01:28:32.739] plan(): nbrOfWorkers() = 1
[01:28:32.768]  - Condition #49: 'simpleMessage', 'message', 'condition'
[01:28:32.742] plan(): Setting new future strategy stack:
[01:28:32.768]  - Condition #50: 'simpleMessage', 'message', 'condition'
[01:28:32.742] List of future strategies:
[01:28:32.742] 1. sequential:
[01:28:32.742]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.742]    - tweaked: FALSE
[01:28:32.742]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.768]  - Condition #51: 'simpleMessage', 'message', 'condition'
[01:28:32.743] plan(): nbrOfWorkers() = 1
[01:28:32.769]  - Condition #52: 'simpleMessage', 'message', 'condition'
[01:28:32.743] SequentialFuture started (and completed)
[01:28:32.769]  - Condition #53: 'simpleMessage', 'message', 'condition'
[01:28:32.744] - Launch lazy future ... done
[01:28:32.769]  - Condition #54: 'simpleMessage', 'message', 'condition'
[01:28:32.744] run() for 'SequentialFuture' ... done
[01:28:32.769] 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"
[01:28:32.777] getGlobalsAndPackages() ...
[01:28:32.777] Searching for globals...
[01:28:32.779] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[01:28:32.779] Searching for globals ... DONE
[01:28:32.779] Resolving globals: FALSE
[01:28:32.780] The total size of the 1 globals is 128 bytes (128 bytes)
[01:28:32.781] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 128 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (128 bytes of class 'list')
[01:28:32.781] - globals: [1] 'data'
[01:28:32.781] - packages: [1] 'future'
[01:28:32.781] getGlobalsAndPackages() ... DONE
[01:28:32.782] run() for 'Future' ...
[01:28:32.782] - state: 'created'
[01:28:32.782] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:32.783] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:32.783] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:32.783]   - Field: 'label'
[01:28:32.783]   - Field: 'local'
[01:28:32.783]   - Field: 'owner'
[01:28:32.784]   - Field: 'envir'
[01:28:32.784]   - Field: 'packages'
[01:28:32.784]   - Field: 'gc'
[01:28:32.784]   - Field: 'conditions'
[01:28:32.784]   - Field: 'expr'
[01:28:32.784]   - Field: 'uuid'
[01:28:32.785]   - Field: 'seed'
[01:28:32.785]   - Field: 'version'
[01:28:32.785]   - Field: 'result'
[01:28:32.785]   - Field: 'asynchronous'
[01:28:32.785]   - Field: 'calls'
[01:28:32.786]   - Field: 'globals'
[01:28:32.786]   - Field: 'stdout'
[01:28:32.786]   - Field: 'earlySignal'
[01:28:32.786]   - Field: 'lazy'
[01:28:32.786]   - Field: 'state'
[01:28:32.786] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:32.787] - Launch lazy future ...
[01:28:32.787] Packages needed by the future expression (n = 1): 'future'
[01:28:32.787] Packages needed by future strategies (n = 1): 'future'
[01:28:32.788] {
[01:28:32.788]     {
[01:28:32.788]         {
[01:28:32.788]             ...future.startTime <- base::Sys.time()
[01:28:32.788]             {
[01:28:32.788]                 {
[01:28:32.788]                   {
[01:28:32.788]                     {
[01:28:32.788]                       base::local({
[01:28:32.788]                         has_future <- base::requireNamespace("future", 
[01:28:32.788]                           quietly = TRUE)
[01:28:32.788]                         if (has_future) {
[01:28:32.788]                           ns <- base::getNamespace("future")
[01:28:32.788]                           version <- ns[[".package"]][["version"]]
[01:28:32.788]                           if (is.null(version)) 
[01:28:32.788]                             version <- utils::packageVersion("future")
[01:28:32.788]                         }
[01:28:32.788]                         else {
[01:28:32.788]                           version <- NULL
[01:28:32.788]                         }
[01:28:32.788]                         if (!has_future || version < "1.8.0") {
[01:28:32.788]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:32.788]                             "", base::R.version$version.string), 
[01:28:32.788]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:32.788]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:32.788]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:32.788]                               "release", "version")], collapse = " "), 
[01:28:32.788]                             hostname = base::Sys.info()[["nodename"]])
[01:28:32.788]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:32.788]                             info)
[01:28:32.788]                           info <- base::paste(info, collapse = "; ")
[01:28:32.788]                           if (!has_future) {
[01:28:32.788]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:32.788]                               info)
[01:28:32.788]                           }
[01:28:32.788]                           else {
[01:28:32.788]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:32.788]                               info, version)
[01:28:32.788]                           }
[01:28:32.788]                           base::stop(msg)
[01:28:32.788]                         }
[01:28:32.788]                       })
[01:28:32.788]                     }
[01:28:32.788]                     base::local({
[01:28:32.788]                       for (pkg in "future") {
[01:28:32.788]                         base::loadNamespace(pkg)
[01:28:32.788]                         base::library(pkg, character.only = TRUE)
[01:28:32.788]                       }
[01:28:32.788]                     })
[01:28:32.788]                   }
[01:28:32.788]                   options(future.plan = NULL)
[01:28:32.788]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.788]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:32.788]                   {
[01:28:32.788]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.788]                     if (!future$lazy) 
[01:28:32.788]                       future <- run(future)
[01:28:32.788]                     invisible(future)
[01:28:32.788]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.788]                 }
[01:28:32.788]                 ...future.workdir <- getwd()
[01:28:32.788]             }
[01:28:32.788]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:32.788]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:32.788]         }
[01:28:32.788]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:32.788]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:32.788]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:32.788]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:32.788]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:32.788]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:32.788]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:32.788]             base::names(...future.oldOptions))
[01:28:32.788]     }
[01:28:32.788]     if (FALSE) {
[01:28:32.788]     }
[01:28:32.788]     else {
[01:28:32.788]         if (TRUE) {
[01:28:32.788]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:32.788]                 open = "w")
[01:28:32.788]         }
[01:28:32.788]         else {
[01:28:32.788]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:32.788]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:32.788]         }
[01:28:32.788]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:32.788]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:32.788]             base::sink(type = "output", split = FALSE)
[01:28:32.788]             base::close(...future.stdout)
[01:28:32.788]         }, add = TRUE)
[01:28:32.788]     }
[01:28:32.788]     ...future.frame <- base::sys.nframe()
[01:28:32.788]     ...future.conditions <- base::list()
[01:28:32.788]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:32.788]     if (FALSE) {
[01:28:32.788]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:32.788]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:32.788]     }
[01:28:32.788]     ...future.result <- base::tryCatch({
[01:28:32.788]         base::withCallingHandlers({
[01:28:32.788]             ...future.value <- base::withVisible(base::local({
[01:28:32.788]                 value(future(subset(data, a == 2)))
[01:28:32.788]             }))
[01:28:32.788]             future::FutureResult(value = ...future.value$value, 
[01:28:32.788]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.788]                   ...future.rng), globalenv = if (FALSE) 
[01:28:32.788]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:32.788]                     ...future.globalenv.names))
[01:28:32.788]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:32.788]         }, condition = base::local({
[01:28:32.788]             c <- base::c
[01:28:32.788]             inherits <- base::inherits
[01:28:32.788]             invokeRestart <- base::invokeRestart
[01:28:32.788]             length <- base::length
[01:28:32.788]             list <- base::list
[01:28:32.788]             seq.int <- base::seq.int
[01:28:32.788]             signalCondition <- base::signalCondition
[01:28:32.788]             sys.calls <- base::sys.calls
[01:28:32.788]             `[[` <- base::`[[`
[01:28:32.788]             `+` <- base::`+`
[01:28:32.788]             `<<-` <- base::`<<-`
[01:28:32.788]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:32.788]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:32.788]                   3L)]
[01:28:32.788]             }
[01:28:32.788]             function(cond) {
[01:28:32.788]                 is_error <- inherits(cond, "error")
[01:28:32.788]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:32.788]                   NULL)
[01:28:32.788]                 if (is_error) {
[01:28:32.788]                   sessionInformation <- function() {
[01:28:32.788]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:32.788]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:32.788]                       search = base::search(), system = base::Sys.info())
[01:28:32.788]                   }
[01:28:32.788]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.788]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:32.788]                     cond$call), session = sessionInformation(), 
[01:28:32.788]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:32.788]                   signalCondition(cond)
[01:28:32.788]                 }
[01:28:32.788]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:32.788]                 "immediateCondition"))) {
[01:28:32.788]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:32.788]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.788]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:32.788]                   if (TRUE && !signal) {
[01:28:32.788]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.788]                     {
[01:28:32.788]                       inherits <- base::inherits
[01:28:32.788]                       invokeRestart <- base::invokeRestart
[01:28:32.788]                       is.null <- base::is.null
[01:28:32.788]                       muffled <- FALSE
[01:28:32.788]                       if (inherits(cond, "message")) {
[01:28:32.788]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.788]                         if (muffled) 
[01:28:32.788]                           invokeRestart("muffleMessage")
[01:28:32.788]                       }
[01:28:32.788]                       else if (inherits(cond, "warning")) {
[01:28:32.788]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.788]                         if (muffled) 
[01:28:32.788]                           invokeRestart("muffleWarning")
[01:28:32.788]                       }
[01:28:32.788]                       else if (inherits(cond, "condition")) {
[01:28:32.788]                         if (!is.null(pattern)) {
[01:28:32.788]                           computeRestarts <- base::computeRestarts
[01:28:32.788]                           grepl <- base::grepl
[01:28:32.788]                           restarts <- computeRestarts(cond)
[01:28:32.788]                           for (restart in restarts) {
[01:28:32.788]                             name <- restart$name
[01:28:32.788]                             if (is.null(name)) 
[01:28:32.788]                               next
[01:28:32.788]                             if (!grepl(pattern, name)) 
[01:28:32.788]                               next
[01:28:32.788]                             invokeRestart(restart)
[01:28:32.788]                             muffled <- TRUE
[01:28:32.788]                             break
[01:28:32.788]                           }
[01:28:32.788]                         }
[01:28:32.788]                       }
[01:28:32.788]                       invisible(muffled)
[01:28:32.788]                     }
[01:28:32.788]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.788]                   }
[01:28:32.788]                 }
[01:28:32.788]                 else {
[01:28:32.788]                   if (TRUE) {
[01:28:32.788]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.788]                     {
[01:28:32.788]                       inherits <- base::inherits
[01:28:32.788]                       invokeRestart <- base::invokeRestart
[01:28:32.788]                       is.null <- base::is.null
[01:28:32.788]                       muffled <- FALSE
[01:28:32.788]                       if (inherits(cond, "message")) {
[01:28:32.788]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.788]                         if (muffled) 
[01:28:32.788]                           invokeRestart("muffleMessage")
[01:28:32.788]                       }
[01:28:32.788]                       else if (inherits(cond, "warning")) {
[01:28:32.788]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.788]                         if (muffled) 
[01:28:32.788]                           invokeRestart("muffleWarning")
[01:28:32.788]                       }
[01:28:32.788]                       else if (inherits(cond, "condition")) {
[01:28:32.788]                         if (!is.null(pattern)) {
[01:28:32.788]                           computeRestarts <- base::computeRestarts
[01:28:32.788]                           grepl <- base::grepl
[01:28:32.788]                           restarts <- computeRestarts(cond)
[01:28:32.788]                           for (restart in restarts) {
[01:28:32.788]                             name <- restart$name
[01:28:32.788]                             if (is.null(name)) 
[01:28:32.788]                               next
[01:28:32.788]                             if (!grepl(pattern, name)) 
[01:28:32.788]                               next
[01:28:32.788]                             invokeRestart(restart)
[01:28:32.788]                             muffled <- TRUE
[01:28:32.788]                             break
[01:28:32.788]                           }
[01:28:32.788]                         }
[01:28:32.788]                       }
[01:28:32.788]                       invisible(muffled)
[01:28:32.788]                     }
[01:28:32.788]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.788]                   }
[01:28:32.788]                 }
[01:28:32.788]             }
[01:28:32.788]         }))
[01:28:32.788]     }, error = function(ex) {
[01:28:32.788]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:32.788]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.788]                 ...future.rng), started = ...future.startTime, 
[01:28:32.788]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:32.788]             version = "1.8"), class = "FutureResult")
[01:28:32.788]     }, finally = {
[01:28:32.788]         if (!identical(...future.workdir, getwd())) 
[01:28:32.788]             setwd(...future.workdir)
[01:28:32.788]         {
[01:28:32.788]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:32.788]                 ...future.oldOptions$nwarnings <- NULL
[01:28:32.788]             }
[01:28:32.788]             base::options(...future.oldOptions)
[01:28:32.788]             if (.Platform$OS.type == "windows") {
[01:28:32.788]                 old_names <- names(...future.oldEnvVars)
[01:28:32.788]                 envs <- base::Sys.getenv()
[01:28:32.788]                 names <- names(envs)
[01:28:32.788]                 common <- intersect(names, old_names)
[01:28:32.788]                 added <- setdiff(names, old_names)
[01:28:32.788]                 removed <- setdiff(old_names, names)
[01:28:32.788]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:32.788]                   envs[common]]
[01:28:32.788]                 NAMES <- toupper(changed)
[01:28:32.788]                 args <- list()
[01:28:32.788]                 for (kk in seq_along(NAMES)) {
[01:28:32.788]                   name <- changed[[kk]]
[01:28:32.788]                   NAME <- NAMES[[kk]]
[01:28:32.788]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.788]                     next
[01:28:32.788]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.788]                 }
[01:28:32.788]                 NAMES <- toupper(added)
[01:28:32.788]                 for (kk in seq_along(NAMES)) {
[01:28:32.788]                   name <- added[[kk]]
[01:28:32.788]                   NAME <- NAMES[[kk]]
[01:28:32.788]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.788]                     next
[01:28:32.788]                   args[[name]] <- ""
[01:28:32.788]                 }
[01:28:32.788]                 NAMES <- toupper(removed)
[01:28:32.788]                 for (kk in seq_along(NAMES)) {
[01:28:32.788]                   name <- removed[[kk]]
[01:28:32.788]                   NAME <- NAMES[[kk]]
[01:28:32.788]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.788]                     next
[01:28:32.788]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.788]                 }
[01:28:32.788]                 if (length(args) > 0) 
[01:28:32.788]                   base::do.call(base::Sys.setenv, args = args)
[01:28:32.788]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:32.788]             }
[01:28:32.788]             else {
[01:28:32.788]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:32.788]             }
[01:28:32.788]             {
[01:28:32.788]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:32.788]                   0L) {
[01:28:32.788]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:32.788]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:32.788]                   base::options(opts)
[01:28:32.788]                 }
[01:28:32.788]                 {
[01:28:32.788]                   {
[01:28:32.788]                     NULL
[01:28:32.788]                     RNGkind("Mersenne-Twister")
[01:28:32.788]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:32.788]                       inherits = FALSE)
[01:28:32.788]                   }
[01:28:32.788]                   options(future.plan = NULL)
[01:28:32.788]                   if (is.na(NA_character_)) 
[01:28:32.788]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.788]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:32.788]                   future::plan(list(a = function (..., envir = parent.frame()) 
[01:28:32.788]                   {
[01:28:32.788]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.788]                     if (!future$lazy) 
[01:28:32.788]                       future <- run(future)
[01:28:32.788]                     invisible(future)
[01:28:32.788]                   }, b = function (..., envir = parent.frame()) 
[01:28:32.788]                   {
[01:28:32.788]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.788]                     if (!future$lazy) 
[01:28:32.788]                       future <- run(future)
[01:28:32.788]                     invisible(future)
[01:28:32.788]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.788]                 }
[01:28:32.788]             }
[01:28:32.788]         }
[01:28:32.788]     })
[01:28:32.788]     if (TRUE) {
[01:28:32.788]         base::sink(type = "output", split = FALSE)
[01:28:32.788]         if (TRUE) {
[01:28:32.788]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:32.788]         }
[01:28:32.788]         else {
[01:28:32.788]             ...future.result["stdout"] <- base::list(NULL)
[01:28:32.788]         }
[01:28:32.788]         base::close(...future.stdout)
[01:28:32.788]         ...future.stdout <- NULL
[01:28:32.788]     }
[01:28:32.788]     ...future.result$conditions <- ...future.conditions
[01:28:32.788]     ...future.result$finished <- base::Sys.time()
[01:28:32.788]     ...future.result
[01:28:32.788] }
[01:28:32.792] assign_globals() ...
[01:28:32.792] List of 1
[01:28:32.792]  $ data:'data.frame':	3 obs. of  2 variables:
[01:28:32.792]   ..$ a: int [1:3] 1 2 3
[01:28:32.792]   ..$ b: int [1:3] 3 2 1
[01:28:32.792]  - attr(*, "where")=List of 1
[01:28:32.792]   ..$ data:<environment: R_EmptyEnv> 
[01:28:32.792]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:32.792]  - attr(*, "resolved")= logi FALSE
[01:28:32.792]  - attr(*, "total_size")= num 128
[01:28:32.792]  - attr(*, "already-done")= logi TRUE
[01:28:32.798] - copied 'data' to environment
[01:28:32.799] assign_globals() ... done
[01:28:32.799] plan(): Setting new future strategy stack:
[01:28:32.799] List of future strategies:
[01:28:32.799] 1. sequential:
[01:28:32.799]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.799]    - tweaked: FALSE
[01:28:32.799]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.800] plan(): nbrOfWorkers() = 1
[01:28:32.840] plan(): Setting new future strategy stack:
[01:28:32.840] List of future strategies:
[01:28:32.840] 1. sequential:
[01:28:32.840]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.840]    - tweaked: FALSE
[01:28:32.840]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.840] 2. sequential:
[01:28:32.840]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.840]    - tweaked: FALSE
[01:28:32.840]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.841] plan(): nbrOfWorkers() = 1
[01:28:32.841] SequentialFuture started (and completed)
[01:28:32.842] signalConditions() ...
[01:28:32.842]  - include = 'immediateCondition'
[01:28:32.842]  - exclude = 
[01:28:32.842]  - resignal = FALSE
[01:28:32.842]  - Number of conditions: 52
[01:28:32.843] signalConditions() ... done
[01:28:32.843] - Launch lazy future ... done
[01:28:32.844] run() for 'SequentialFuture' ... done
[01:28:32.844] signalConditions() ...
[01:28:32.844]  - include = 'immediateCondition'
[01:28:32.844]  - exclude = 
[01:28:32.844]  - resignal = FALSE
[01:28:32.845]  - Number of conditions: 52
[01:28:32.845] signalConditions() ... done
[01:28:32.845] Future state: 'finished'
[01:28:32.845] signalConditions() ...
[01:28:32.845]  - include = 'condition'
[01:28:32.845]  - exclude = 'immediateCondition'
[01:28:32.846]  - resignal = TRUE
[01:28:32.846]  - Number of conditions: 52
[01:28:32.846]  - Condition #1: 'simpleMessage', 'message', 'condition'
[01:28:32.801] getGlobalsAndPackages() ...
[01:28:32.846]  - Condition #2: 'simpleMessage', 'message', 'condition'
[01:28:32.801] Searching for globals...
[01:28:32.846]  - Condition #3: 'simpleMessage', 'message', 'condition'
[01:28:32.819] - globals found: [4] 'subset', 'data', '==', 'a'
[01:28:32.847]  - Condition #4: 'simpleMessage', 'message', 'condition'
[01:28:32.819] Searching for globals ... DONE
[01:28:32.847]  - Condition #5: 'simpleMessage', 'message', 'condition'
[01:28:32.819] Resolving globals: FALSE
[01:28:32.847]  - Condition #6: 'simpleMessage', 'message', 'condition'
[01:28:32.820] The total size of the 1 globals is 128 bytes (128 bytes)
[01:28:32.847]  - Condition #7: 'simpleMessage', 'message', 'condition'
[01:28:32.820] The total size of the 1 globals exported for future expression ('subset(data, a == 2)') is 128 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (128 bytes of class 'list')
[01:28:32.847]  - Condition #8: 'simpleMessage', 'message', 'condition'
[01:28:32.820] - globals: [1] 'data'
[01:28:32.848]  - Condition #9: 'simpleMessage', 'message', 'condition'
[01:28:32.821] 
[01:28:32.848]  - Condition #10: 'simpleMessage', 'message', 'condition'
[01:28:32.821] getGlobalsAndPackages() ... DONE
[01:28:32.848]  - Condition #11: 'simpleMessage', 'message', 'condition'
[01:28:32.821] run() for 'Future' ...
[01:28:32.848]  - Condition #12: 'simpleMessage', 'message', 'condition'
[01:28:32.821] - state: 'created'
[01:28:32.849]  - Condition #13: 'simpleMessage', 'message', 'condition'
[01:28:32.822] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:32.849]  - Condition #14: 'simpleMessage', 'message', 'condition'
[01:28:32.822] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:32.849]  - Condition #15: 'simpleMessage', 'message', 'condition'
[01:28:32.822] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:32.849]  - Condition #16: 'simpleMessage', 'message', 'condition'
[01:28:32.822]   - Field: 'label'
[01:28:32.849]  - Condition #17: 'simpleMessage', 'message', 'condition'
[01:28:32.823]   - Field: 'local'
[01:28:32.850]  - Condition #18: 'simpleMessage', 'message', 'condition'
[01:28:32.823]   - Field: 'owner'
[01:28:32.850]  - Condition #19: 'simpleMessage', 'message', 'condition'
[01:28:32.823]   - Field: 'envir'
[01:28:32.850]  - Condition #20: 'simpleMessage', 'message', 'condition'
[01:28:32.823]   - Field: 'packages'
[01:28:32.850]  - Condition #21: 'simpleMessage', 'message', 'condition'
[01:28:32.823]   - Field: 'gc'
[01:28:32.850]  - Condition #22: 'simpleMessage', 'message', 'condition'
[01:28:32.824]   - Field: 'conditions'
[01:28:32.851]  - Condition #23: 'simpleMessage', 'message', 'condition'
[01:28:32.824]   - Field: 'expr'
[01:28:32.851]  - Condition #24: 'simpleMessage', 'message', 'condition'
[01:28:32.824]   - Field: 'uuid'
[01:28:32.851]  - Condition #25: 'simpleMessage', 'message', 'condition'
[01:28:32.824]   - Field: 'seed'
[01:28:32.851]  - Condition #26: 'simpleMessage', 'message', 'condition'
[01:28:32.824]   - Field: 'version'
[01:28:32.851]  - Condition #27: 'simpleMessage', 'message', 'condition'
[01:28:32.825]   - Field: 'result'
[01:28:32.852]  - Condition #28: 'simpleMessage', 'message', 'condition'
[01:28:32.825]   - Field: 'asynchronous'
[01:28:32.852]  - Condition #29: 'simpleMessage', 'message', 'condition'
[01:28:32.825]   - Field: 'calls'
[01:28:32.852]  - Condition #30: 'simpleMessage', 'message', 'condition'
[01:28:32.825]   - Field: 'globals'
[01:28:32.852]  - Condition #31: 'simpleMessage', 'message', 'condition'
[01:28:32.825]   - Field: 'stdout'
[01:28:32.852]  - Condition #32: 'simpleMessage', 'message', 'condition'
[01:28:32.826]   - Field: 'earlySignal'
[01:28:32.853]  - Condition #33: 'simpleMessage', 'message', 'condition'
[01:28:32.826]   - Field: 'lazy'
[01:28:32.853]  - Condition #34: 'simpleMessage', 'message', 'condition'
[01:28:32.826]   - Field: 'state'
[01:28:32.853]  - Condition #35: 'simpleMessage', 'message', 'condition'
[01:28:32.826] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:32.853]  - Condition #36: 'simpleMessage', 'message', 'condition'
[01:28:32.826] - Launch lazy future ...
[01:28:32.854]  - Condition #37: 'simpleMessage', 'message', 'condition'
[01:28:32.827] Packages needed by the future expression (n = 0): <none>
[01:28:32.854]  - Condition #38: 'simpleMessage', 'message', 'condition'
[01:28:32.827] Packages needed by future strategies (n = 0): <none>
[01:28:32.854]  - Condition #39: 'simpleMessage', 'message', 'condition'
[01:28:32.827] {
[01:28:32.827]     {
[01:28:32.827]         {
[01:28:32.827]             ...future.startTime <- base::Sys.time()
[01:28:32.827]             {
[01:28:32.827]                 {
[01:28:32.827]                   {
[01:28:32.827]                     base::local({
[01:28:32.827]                       has_future <- base::requireNamespace("future", 
[01:28:32.827]                         quietly = TRUE)
[01:28:32.827]                       if (has_future) {
[01:28:32.827]                         ns <- base::getNamespace("future")
[01:28:32.827]                         version <- ns[[".package"]][["version"]]
[01:28:32.827]                         if (is.null(version)) 
[01:28:32.827]                           version <- utils::packageVersion("future")
[01:28:32.827]                       }
[01:28:32.827]                       else {
[01:28:32.827]                         version <- NULL
[01:28:32.827]                       }
[01:28:32.827]                       if (!has_future || version < "1.8.0") {
[01:28:32.827]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:32.827]                           "", base::R.version$version.string), 
[01:28:32.827]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:32.827]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:32.827]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:32.827]                             "release", "version")], collapse = " "), 
[01:28:32.827]                           hostname = base::Sys.info()[["nodename"]])
[01:28:32.827]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:32.827]                           info)
[01:28:32.827]                         info <- base::paste(info, collapse = "; ")
[01:28:32.827]                         if (!has_future) {
[01:28:32.827]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:32.827]                             info)
[01:28:32.827]                         }
[01:28:32.827]                         else {
[01:28:32.827]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:32.827]                             info, version)
[01:28:32.827]                         }
[01:28:32.827]                         base::stop(msg)
[01:28:32.827]                       }
[01:28:32.827]                     })
[01:28:32.827]                   }
[01:28:32.827]                   options(future.plan = NULL)
[01:28:32.827]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.827]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:32.827]                 }
[01:28:32.827]                 ...future.workdir <- getwd()
[01:28:32.827]             }
[01:28:32.827]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:32.827]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:32.827]         }
[01:28:32.827]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:32.827]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:32.827]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:32.827]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:32.827]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:32.827]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:32.827]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:32.827]             base::names(...future.oldOptions))
[01:28:32.827]     }
[01:28:32.827]     if (FALSE) {
[01:28:32.827]     }
[01:28:32.827]     else {
[01:28:32.827]         if (TRUE) {
[01:28:32.827]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:32.827]                 open = "w")
[01:28:32.827]         }
[01:28:32.827]         else {
[01:28:32.827]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:32.827]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:32.827]         }
[01:28:32.827]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:32.827]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:32.827]             base::sink(type = "output", split = FALSE)
[01:28:32.827]             base::close(...future.stdout)
[01:28:32.827]         }, add = TRUE)
[01:28:32.827]     }
[01:28:32.827]     ...future.frame <- base::sys.nframe()
[01:28:32.827]     ...future.conditions <- base::list()
[01:28:32.827]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:32.827]     if (FALSE) {
[01:28:32.827]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:32.827]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:32.827]     }
[01:28:32.827]     ...future.result <- base::tryCatch({
[01:28:32.827]         base::withCallingHandlers({
[01:28:32.827]             ...future.value <- base::withVisible(base::local(subset(data, 
[01:28:32.827]                 a == 2)))
[01:28:32.827]             future::FutureResult(value = ...future.value$value, 
[01:28:32.827]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.827]                   ...future.rng), globalenv = if (FALSE) 
[01:28:32.827]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:32.827]                     ...future.globalenv.names))
[01:28:32.827]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:32.827]         }, condition = base::local({
[01:28:32.827]             c <- base::c
[01:28:32.827]             inherits <- base::inherits
[01:28:32.827]             invokeRestart <- base::invokeRestart
[01:28:32.827]             length <- base::length
[01:28:32.827]             list <- base::list
[01:28:32.827]             seq.int <- base::seq.int
[01:28:32.827]             signalCondition <- base::signalCondition
[01:28:32.827]             sys.calls <- base::sys.calls
[01:28:32.827]             `[[` <- base::`[[`
[01:28:32.827]             `+` <- base::`+`
[01:28:32.827]             `<<-` <- base::`<<-`
[01:28:32.827]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:32.827]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:32.827]                   3L)]
[01:28:32.827]             }
[01:28:32.827]             function(cond) {
[01:28:32.827]                 is_error <- inherits(cond, "error")
[01:28:32.827]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:32.827]                   NULL)
[01:28:32.827]                 if (is_error) {
[01:28:32.827]                   sessionInformation <- function() {
[01:28:32.827]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:32.827]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:32.827]                       search = base::search(), system = base::Sys.info())
[01:28:32.827]                   }
[01:28:32.827]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.827]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:32.827]                     cond$call), session = sessionInformation(), 
[01:28:32.827]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:32.827]                   signalCondition(cond)
[01:28:32.827]                 }
[01:28:32.827]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:32.827]                 "immediateCondition"))) {
[01:28:32.827]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:32.827]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.827]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:32.827]                   if (TRUE && !signal) {
[01:28:32.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.827]                     {
[01:28:32.827]                       inherits <- base::inherits
[01:28:32.827]                       invokeRestart <- base::invokeRestart
[01:28:32.827]                       is.null <- base::is.null
[01:28:32.827]                       muffled <- FALSE
[01:28:32.827]                       if (inherits(cond, "message")) {
[01:28:32.827]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.827]                         if (muffled) 
[01:28:32.827]                           invokeRestart("muffleMessage")
[01:28:32.827]                       }
[01:28:32.827]                       else if (inherits(cond, "warning")) {
[01:28:32.827]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.827]                         if (muffled) 
[01:28:32.827]                           invokeRestart("muffleWarning")
[01:28:32.827]                       }
[01:28:32.827]                       else if (inherits(cond, "condition")) {
[01:28:32.827]                         if (!is.null(pattern)) {
[01:28:32.827]                           computeRestarts <- base::computeRestarts
[01:28:32.827]                           grepl <- base::grepl
[01:28:32.827]                           restarts <- computeRestarts(cond)
[01:28:32.827]                           for (restart in restarts) {
[01:28:32.827]                             name <- restart$name
[01:28:32.827]                             if (is.null(name)) 
[01:28:32.827]                               next
[01:28:32.827]                             if (!grepl(pattern, name)) 
[01:28:32.827]                               next
[01:28:32.827]                             invokeRestart(restart)
[01:28:32.827]                             muffled <- TRUE
[01:28:32.827]                             break
[01:28:32.827]                           }
[01:28:32.827]                         }
[01:28:32.827]                       }
[01:28:32.827]                       invisible(muffled)
[01:28:32.827]                     }
[01:28:32.827]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.827]                   }
[01:28:32.827]                 }
[01:28:32.827]                 else {
[01:28:32.827]                   if (TRUE) {
[01:28:32.827]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.827]                     {
[01:28:32.827]                       inherits <- base::inherits
[01:28:32.827]                       invokeRestart <- base::invokeRestart
[01:28:32.827]                       is.null <- base::is.null
[01:28:32.827]                       muffled <- FALSE
[01:28:32.827]                       if (inherits(cond, "message")) {
[01:28:32.827]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.827]                         if (muffled) 
[01:28:32.827]                           invokeRestart("muffleMessage")
[01:28:32.827]                       }
[01:28:32.827]                       else if (inherits(cond, "warning")) {
[01:28:32.827]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.827]                         if (muffled) 
[01:28:32.827]                           invokeRestart("muffleWarning")
[01:28:32.827]                       }
[01:28:32.827]                       else if (inherits(cond, "condition")) {
[01:28:32.827]                         if (!is.null(pattern)) {
[01:28:32.827]                           computeRestarts <- base::computeRestarts
[01:28:32.827]                           grepl <- base::grepl
[01:28:32.827]                           restarts <- computeRestarts(cond)
[01:28:32.827]                           for (restart in restarts) {
[01:28:32.827]                             name <- restart$name
[01:28:32.827]                             if (is.null(name)) 
[01:28:32.827]                               next
[01:28:32.827]                             if (!grepl(pattern, name)) 
[01:28:32.827]                               next
[01:28:32.827]                             invokeRestart(restart)
[01:28:32.827]                             muffled <- TRUE
[01:28:32.827]                             break
[01:28:32.827]                           }
[01:28:32.827]                         }
[01:28:32.827]                       }
[01:28:32.827]                       invisible(muffled)
[01:28:32.827]                     }
[01:28:32.827]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.827]                   }
[01:28:32.827]                 }
[01:28:32.827]             }
[01:28:32.827]         }))
[01:28:32.827]     }, error = function(ex) {
[01:28:32.827]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:32.827]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.827]                 ...future.rng), started = ...future.startTime, 
[01:28:32.827]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:32.827]             version = "1.8"), class = "FutureResult")
[01:28:32.827]     }, finally = {
[01:28:32.827]         if (!identical(...future.workdir, getwd())) 
[01:28:32.827]             setwd(...future.workdir)
[01:28:32.827]         {
[01:28:32.827]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:32.827]                 ...future.oldOptions$nwarnings <- NULL
[01:28:32.827]             }
[01:28:32.827]             base::options(...future.oldOptions)
[01:28:32.827]             if (.Platform$OS.type == "windows") {
[01:28:32.827]                 old_names <- names(...future.oldEnvVars)
[01:28:32.827]                 envs <- base::Sys.getenv()
[01:28:32.827]                 names <- names(envs)
[01:28:32.827]                 common <- intersect(names, old_names)
[01:28:32.827]                 added <- setdiff(names, old_names)
[01:28:32.827]                 removed <- setdiff(old_names, names)
[01:28:32.827]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:32.827]                   envs[common]]
[01:28:32.827]                 NAMES <- toupper(changed)
[01:28:32.827]                 args <- list()
[01:28:32.827]                 for (kk in seq_along(NAMES)) {
[01:28:32.827]                   name <- changed[[kk]]
[01:28:32.827]                   NAME <- NAMES[[kk]]
[01:28:32.827]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.827]                     next
[01:28:32.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.827]                 }
[01:28:32.827]                 NAMES <- toupper(added)
[01:28:32.827]                 for (kk in seq_along(NAMES)) {
[01:28:32.827]                   name <- added[[kk]]
[01:28:32.827]                   NAME <- NAMES[[kk]]
[01:28:32.827]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.827]                     next
[01:28:32.827]                   args[[name]] <- ""
[01:28:32.827]                 }
[01:28:32.827]                 NAMES <- toupper(removed)
[01:28:32.827]                 for (kk in seq_along(NAMES)) {
[01:28:32.827]                   name <- removed[[kk]]
[01:28:32.827]                   NAME <- NAMES[[kk]]
[01:28:32.827]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.827]                     next
[01:28:32.827]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.827]                 }
[01:28:32.827]                 if (length(args) > 0) 
[01:28:32.827]                   base::do.call(base::Sys.setenv, args = args)
[01:28:32.827]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:32.827]             }
[01:28:32.827]             else {
[01:28:32.827]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:32.827]             }
[01:28:32.827]             {
[01:28:32.827]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:32.827]                   0L) {
[01:28:32.827]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:32.827]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:32.827]                   base::options(opts)
[01:28:32.827]                 }
[01:28:32.827]                 {
[01:28:32.827]                   {
[01:28:32.827]                     NULL
[01:28:32.827]                     RNGkind("Mersenne-Twister")
[01:28:32.827]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:32.827]                       inherits = FALSE)
[01:28:32.827]                   }
[01:28:32.827]                   options(future.plan = NULL)
[01:28:32.827]                   if (is.na(NA_character_)) 
[01:28:32.827]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.827]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:32.827]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:32.827]                   {
[01:28:32.827]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.827]                     if (!future$lazy) 
[01:28:32.827]                       future <- run(future)
[01:28:32.827]                     invisible(future)
[01:28:32.827]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.827]                 }
[01:28:32.827]             }
[01:28:32.827]         }
[01:28:32.827]     })
[01:28:32.827]     if (TRUE) {
[01:28:32.827]         base::sink(type = "output", split = FALSE)
[01:28:32.827]         if (TRUE) {
[01:28:32.827]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:32.827]         }
[01:28:32.827]         else {
[01:28:32.827]             ...future.result["stdout"] <- base::list(NULL)
[01:28:32.827]         }
[01:28:32.827]         base::close(...future.stdout)
[01:28:32.827]         ...future.stdout <- NULL
[01:28:32.827]     }
[01:28:32.827]     ...future.result$conditions <- ...future.conditions
[01:28:32.827]     ...future.result$finished <- base::Sys.time()
[01:28:32.827]     ...future.result
[01:28:32.827] }
[01:28:32.854]  - Condition #40: 'simpleMessage', 'message', 'condition'
[01:28:32.831] assign_globals() ...
[01:28:32.855]  - Condition #41: 'simpleMessage', 'message', 'condition'
[01:28:32.831] List of 1
[01:28:32.831]  $ data:'data.frame':	3 obs. of  2 variables:
[01:28:32.831]   ..$ a: int [1:3] 1 2 3
[01:28:32.831]   ..$ b: int [1:3] 3 2 1
[01:28:32.831]  - attr(*, "where")=List of 1
[01:28:32.831]   ..$ data:<environment: R_EmptyEnv> 
[01:28:32.831]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:32.831]  - attr(*, "resolved")= logi FALSE
[01:28:32.831]  - attr(*, "total_size")= num 128
[01:28:32.831]  - attr(*, "already-done")= logi TRUE
[01:28:32.855]  - Condition #42: 'simpleMessage', 'message', 'condition'
[01:28:32.835] - copied 'data' to environment
[01:28:32.855]  - Condition #43: 'simpleMessage', 'message', 'condition'
[01:28:32.835] assign_globals() ... done
[01:28:32.855]  - Condition #44: 'simpleMessage', 'message', 'condition'
[01:28:32.835] plan(): Setting new future strategy stack:
[01:28:32.855]  - Condition #45: 'simpleMessage', 'message', 'condition'
[01:28:32.836] List of future strategies:
[01:28:32.836] 1. sequential:
[01:28:32.836]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.836]    - tweaked: FALSE
[01:28:32.836]    - call: NULL
[01:28:32.856]  - Condition #46: 'simpleMessage', 'message', 'condition'
[01:28:32.836] plan(): nbrOfWorkers() = 1
[01:28:32.856]  - Condition #47: 'simpleMessage', 'message', 'condition'
[01:28:32.838] plan(): Setting new future strategy stack:
[01:28:32.856]  - Condition #48: 'simpleMessage', 'message', 'condition'
[01:28:32.838] List of future strategies:
[01:28:32.838] 1. sequential:
[01:28:32.838]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.838]    - tweaked: FALSE
[01:28:32.838]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.856]  - Condition #49: 'simpleMessage', 'message', 'condition'
[01:28:32.838] plan(): nbrOfWorkers() = 1
[01:28:32.856]  - Condition #50: 'simpleMessage', 'message', 'condition'
[01:28:32.839] SequentialFuture started (and completed)
[01:28:32.857]  - Condition #51: 'simpleMessage', 'message', 'condition'
[01:28:32.839] - Launch lazy future ... done
[01:28:32.857]  - Condition #52: 'simpleMessage', 'message', 'condition'
[01:28:32.839] run() for 'SequentialFuture' ... done
[01:28:32.857] signalConditions() ... done
- plan(list('sequential', 'sequential')) ... DONE
- plan(list('sequential', 'multisession')) ...
[01:28:32.858] plan(): Setting new future strategy stack:
[01:28:32.858] List of future strategies:
[01:28:32.858] 1. sequential:
[01:28:32.858]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:32.858]    - tweaked: FALSE
[01:28:32.858]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.858] 2. multisession:
[01:28:32.858]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:32.858]    - tweaked: FALSE
[01:28:32.858]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.859] plan(): nbrOfWorkers() = 1
[01:28:32.859] getGlobalsAndPackages() ...
[01:28:32.859] Searching for globals...
[01:28:32.881] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[01:28:32.881] Searching for globals ... DONE
[01:28:32.881] Resolving globals: FALSE
[01:28:32.883] The total size of the 2 globals is 55.41 KiB (56736 bytes)
[01:28:32.884] 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 55.41 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (55.29 KiB of class 'list') and 'strategy2' (120 bytes of class 'character')
[01:28:32.884] - globals: [2] 'nested', 'strategy2'
[01:28:32.884] - packages: [1] 'future'
[01:28:32.884] getGlobalsAndPackages() ... DONE
[01:28:32.885] run() for 'Future' ...
[01:28:32.885] - state: 'created'
[01:28:32.885] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:32.886] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:32.886] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:32.886]   - Field: 'label'
[01:28:32.886]   - Field: 'local'
[01:28:32.886]   - Field: 'owner'
[01:28:32.887]   - Field: 'envir'
[01:28:32.887]   - Field: 'packages'
[01:28:32.887]   - Field: 'gc'
[01:28:32.887]   - Field: 'conditions'
[01:28:32.887]   - Field: 'expr'
[01:28:32.887]   - Field: 'uuid'
[01:28:32.888]   - Field: 'seed'
[01:28:32.888]   - Field: 'version'
[01:28:32.888]   - Field: 'result'
[01:28:32.888]   - Field: 'asynchronous'
[01:28:32.888]   - Field: 'calls'
[01:28:32.888]   - Field: 'globals'
[01:28:32.889]   - Field: 'stdout'
[01:28:32.889]   - Field: 'earlySignal'
[01:28:32.889]   - Field: 'lazy'
[01:28:32.889]   - Field: 'state'
[01:28:32.889] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:32.890] - Launch lazy future ...
[01:28:32.890] Packages needed by the future expression (n = 1): 'future'
[01:28:32.890] Packages needed by future strategies (n = 1): 'future'
[01:28:32.891] {
[01:28:32.891]     {
[01:28:32.891]         {
[01:28:32.891]             ...future.startTime <- base::Sys.time()
[01:28:32.891]             {
[01:28:32.891]                 {
[01:28:32.891]                   {
[01:28:32.891]                     {
[01:28:32.891]                       base::local({
[01:28:32.891]                         has_future <- base::requireNamespace("future", 
[01:28:32.891]                           quietly = TRUE)
[01:28:32.891]                         if (has_future) {
[01:28:32.891]                           ns <- base::getNamespace("future")
[01:28:32.891]                           version <- ns[[".package"]][["version"]]
[01:28:32.891]                           if (is.null(version)) 
[01:28:32.891]                             version <- utils::packageVersion("future")
[01:28:32.891]                         }
[01:28:32.891]                         else {
[01:28:32.891]                           version <- NULL
[01:28:32.891]                         }
[01:28:32.891]                         if (!has_future || version < "1.8.0") {
[01:28:32.891]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:32.891]                             "", base::R.version$version.string), 
[01:28:32.891]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:32.891]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:32.891]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:32.891]                               "release", "version")], collapse = " "), 
[01:28:32.891]                             hostname = base::Sys.info()[["nodename"]])
[01:28:32.891]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:32.891]                             info)
[01:28:32.891]                           info <- base::paste(info, collapse = "; ")
[01:28:32.891]                           if (!has_future) {
[01:28:32.891]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:32.891]                               info)
[01:28:32.891]                           }
[01:28:32.891]                           else {
[01:28:32.891]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:32.891]                               info, version)
[01:28:32.891]                           }
[01:28:32.891]                           base::stop(msg)
[01:28:32.891]                         }
[01:28:32.891]                       })
[01:28:32.891]                     }
[01:28:32.891]                     base::local({
[01:28:32.891]                       for (pkg in "future") {
[01:28:32.891]                         base::loadNamespace(pkg)
[01:28:32.891]                         base::library(pkg, character.only = TRUE)
[01:28:32.891]                       }
[01:28:32.891]                     })
[01:28:32.891]                   }
[01:28:32.891]                   options(future.plan = NULL)
[01:28:32.891]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.891]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:32.891]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:32.891]                     envir = parent.frame()) 
[01:28:32.891]                   {
[01:28:32.891]                     if (is.function(workers)) 
[01:28:32.891]                       workers <- workers()
[01:28:32.891]                     workers <- structure(as.integer(workers), 
[01:28:32.891]                       class = class(workers))
[01:28:32.891]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:32.891]                       workers >= 1)
[01:28:32.891]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:32.891]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:32.891]                     }
[01:28:32.891]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:32.891]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:32.891]                       envir = envir)
[01:28:32.891]                     if (!future$lazy) 
[01:28:32.891]                       future <- run(future)
[01:28:32.891]                     invisible(future)
[01:28:32.891]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.891]                 }
[01:28:32.891]                 ...future.workdir <- getwd()
[01:28:32.891]             }
[01:28:32.891]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:32.891]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:32.891]         }
[01:28:32.891]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:32.891]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:32.891]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:32.891]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:32.891]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:32.891]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:32.891]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:32.891]             base::names(...future.oldOptions))
[01:28:32.891]     }
[01:28:32.891]     if (FALSE) {
[01:28:32.891]     }
[01:28:32.891]     else {
[01:28:32.891]         if (TRUE) {
[01:28:32.891]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:32.891]                 open = "w")
[01:28:32.891]         }
[01:28:32.891]         else {
[01:28:32.891]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:32.891]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:32.891]         }
[01:28:32.891]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:32.891]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:32.891]             base::sink(type = "output", split = FALSE)
[01:28:32.891]             base::close(...future.stdout)
[01:28:32.891]         }, add = TRUE)
[01:28:32.891]     }
[01:28:32.891]     ...future.frame <- base::sys.nframe()
[01:28:32.891]     ...future.conditions <- base::list()
[01:28:32.891]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:32.891]     if (FALSE) {
[01:28:32.891]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:32.891]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:32.891]     }
[01:28:32.891]     ...future.result <- base::tryCatch({
[01:28:32.891]         base::withCallingHandlers({
[01:28:32.891]             ...future.value <- base::withVisible(base::local({
[01:28:32.891]                 a <- 1L
[01:28:32.891]                 plan_a <- unclass(future::plan("list"))
[01:28:32.891]                 nested_a <- nested[-1]
[01:28:32.891]                 stopifnot(length(nested_a) == 1L, length(plan_a) == 
[01:28:32.891]                   1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[01:28:32.891]                   strategy2))
[01:28:32.891]                 for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[01:28:32.891]                   "init") <- NULL
[01:28:32.891]                 for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[01:28:32.891]                   "init") <- NULL
[01:28:32.891]                 stopifnot(all.equal(plan_a, nested_a))
[01:28:32.891]                 y %<-% {
[01:28:32.891]                   b <- 2L
[01:28:32.891]                   plan_b <- future::plan("list")
[01:28:32.891]                   nested_b <- nested_a[-1]
[01:28:32.891]                   stopifnot(length(nested_b) == 0L, length(plan_b) == 
[01:28:32.891]                     1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[01:28:32.891]                     "sequential"))
[01:28:32.891]                   list(a = a, nested_a = nested_a, plan_a = plan_a, 
[01:28:32.891]                     b = b, nested_b = nested_b, plan_b = plan_b)
[01:28:32.891]                 }
[01:28:32.891]                 y
[01:28:32.891]             }))
[01:28:32.891]             future::FutureResult(value = ...future.value$value, 
[01:28:32.891]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.891]                   ...future.rng), globalenv = if (FALSE) 
[01:28:32.891]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:32.891]                     ...future.globalenv.names))
[01:28:32.891]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:32.891]         }, condition = base::local({
[01:28:32.891]             c <- base::c
[01:28:32.891]             inherits <- base::inherits
[01:28:32.891]             invokeRestart <- base::invokeRestart
[01:28:32.891]             length <- base::length
[01:28:32.891]             list <- base::list
[01:28:32.891]             seq.int <- base::seq.int
[01:28:32.891]             signalCondition <- base::signalCondition
[01:28:32.891]             sys.calls <- base::sys.calls
[01:28:32.891]             `[[` <- base::`[[`
[01:28:32.891]             `+` <- base::`+`
[01:28:32.891]             `<<-` <- base::`<<-`
[01:28:32.891]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:32.891]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:32.891]                   3L)]
[01:28:32.891]             }
[01:28:32.891]             function(cond) {
[01:28:32.891]                 is_error <- inherits(cond, "error")
[01:28:32.891]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:32.891]                   NULL)
[01:28:32.891]                 if (is_error) {
[01:28:32.891]                   sessionInformation <- function() {
[01:28:32.891]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:32.891]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:32.891]                       search = base::search(), system = base::Sys.info())
[01:28:32.891]                   }
[01:28:32.891]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.891]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:32.891]                     cond$call), session = sessionInformation(), 
[01:28:32.891]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:32.891]                   signalCondition(cond)
[01:28:32.891]                 }
[01:28:32.891]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:32.891]                 "immediateCondition"))) {
[01:28:32.891]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:32.891]                   ...future.conditions[[length(...future.conditions) + 
[01:28:32.891]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:32.891]                   if (TRUE && !signal) {
[01:28:32.891]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.891]                     {
[01:28:32.891]                       inherits <- base::inherits
[01:28:32.891]                       invokeRestart <- base::invokeRestart
[01:28:32.891]                       is.null <- base::is.null
[01:28:32.891]                       muffled <- FALSE
[01:28:32.891]                       if (inherits(cond, "message")) {
[01:28:32.891]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.891]                         if (muffled) 
[01:28:32.891]                           invokeRestart("muffleMessage")
[01:28:32.891]                       }
[01:28:32.891]                       else if (inherits(cond, "warning")) {
[01:28:32.891]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.891]                         if (muffled) 
[01:28:32.891]                           invokeRestart("muffleWarning")
[01:28:32.891]                       }
[01:28:32.891]                       else if (inherits(cond, "condition")) {
[01:28:32.891]                         if (!is.null(pattern)) {
[01:28:32.891]                           computeRestarts <- base::computeRestarts
[01:28:32.891]                           grepl <- base::grepl
[01:28:32.891]                           restarts <- computeRestarts(cond)
[01:28:32.891]                           for (restart in restarts) {
[01:28:32.891]                             name <- restart$name
[01:28:32.891]                             if (is.null(name)) 
[01:28:32.891]                               next
[01:28:32.891]                             if (!grepl(pattern, name)) 
[01:28:32.891]                               next
[01:28:32.891]                             invokeRestart(restart)
[01:28:32.891]                             muffled <- TRUE
[01:28:32.891]                             break
[01:28:32.891]                           }
[01:28:32.891]                         }
[01:28:32.891]                       }
[01:28:32.891]                       invisible(muffled)
[01:28:32.891]                     }
[01:28:32.891]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.891]                   }
[01:28:32.891]                 }
[01:28:32.891]                 else {
[01:28:32.891]                   if (TRUE) {
[01:28:32.891]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:32.891]                     {
[01:28:32.891]                       inherits <- base::inherits
[01:28:32.891]                       invokeRestart <- base::invokeRestart
[01:28:32.891]                       is.null <- base::is.null
[01:28:32.891]                       muffled <- FALSE
[01:28:32.891]                       if (inherits(cond, "message")) {
[01:28:32.891]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:32.891]                         if (muffled) 
[01:28:32.891]                           invokeRestart("muffleMessage")
[01:28:32.891]                       }
[01:28:32.891]                       else if (inherits(cond, "warning")) {
[01:28:32.891]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:32.891]                         if (muffled) 
[01:28:32.891]                           invokeRestart("muffleWarning")
[01:28:32.891]                       }
[01:28:32.891]                       else if (inherits(cond, "condition")) {
[01:28:32.891]                         if (!is.null(pattern)) {
[01:28:32.891]                           computeRestarts <- base::computeRestarts
[01:28:32.891]                           grepl <- base::grepl
[01:28:32.891]                           restarts <- computeRestarts(cond)
[01:28:32.891]                           for (restart in restarts) {
[01:28:32.891]                             name <- restart$name
[01:28:32.891]                             if (is.null(name)) 
[01:28:32.891]                               next
[01:28:32.891]                             if (!grepl(pattern, name)) 
[01:28:32.891]                               next
[01:28:32.891]                             invokeRestart(restart)
[01:28:32.891]                             muffled <- TRUE
[01:28:32.891]                             break
[01:28:32.891]                           }
[01:28:32.891]                         }
[01:28:32.891]                       }
[01:28:32.891]                       invisible(muffled)
[01:28:32.891]                     }
[01:28:32.891]                     muffleCondition(cond, pattern = "^muffle")
[01:28:32.891]                   }
[01:28:32.891]                 }
[01:28:32.891]             }
[01:28:32.891]         }))
[01:28:32.891]     }, error = function(ex) {
[01:28:32.891]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:32.891]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:32.891]                 ...future.rng), started = ...future.startTime, 
[01:28:32.891]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:32.891]             version = "1.8"), class = "FutureResult")
[01:28:32.891]     }, finally = {
[01:28:32.891]         if (!identical(...future.workdir, getwd())) 
[01:28:32.891]             setwd(...future.workdir)
[01:28:32.891]         {
[01:28:32.891]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:32.891]                 ...future.oldOptions$nwarnings <- NULL
[01:28:32.891]             }
[01:28:32.891]             base::options(...future.oldOptions)
[01:28:32.891]             if (.Platform$OS.type == "windows") {
[01:28:32.891]                 old_names <- names(...future.oldEnvVars)
[01:28:32.891]                 envs <- base::Sys.getenv()
[01:28:32.891]                 names <- names(envs)
[01:28:32.891]                 common <- intersect(names, old_names)
[01:28:32.891]                 added <- setdiff(names, old_names)
[01:28:32.891]                 removed <- setdiff(old_names, names)
[01:28:32.891]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:32.891]                   envs[common]]
[01:28:32.891]                 NAMES <- toupper(changed)
[01:28:32.891]                 args <- list()
[01:28:32.891]                 for (kk in seq_along(NAMES)) {
[01:28:32.891]                   name <- changed[[kk]]
[01:28:32.891]                   NAME <- NAMES[[kk]]
[01:28:32.891]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.891]                     next
[01:28:32.891]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.891]                 }
[01:28:32.891]                 NAMES <- toupper(added)
[01:28:32.891]                 for (kk in seq_along(NAMES)) {
[01:28:32.891]                   name <- added[[kk]]
[01:28:32.891]                   NAME <- NAMES[[kk]]
[01:28:32.891]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.891]                     next
[01:28:32.891]                   args[[name]] <- ""
[01:28:32.891]                 }
[01:28:32.891]                 NAMES <- toupper(removed)
[01:28:32.891]                 for (kk in seq_along(NAMES)) {
[01:28:32.891]                   name <- removed[[kk]]
[01:28:32.891]                   NAME <- NAMES[[kk]]
[01:28:32.891]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:32.891]                     next
[01:28:32.891]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:32.891]                 }
[01:28:32.891]                 if (length(args) > 0) 
[01:28:32.891]                   base::do.call(base::Sys.setenv, args = args)
[01:28:32.891]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:32.891]             }
[01:28:32.891]             else {
[01:28:32.891]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:32.891]             }
[01:28:32.891]             {
[01:28:32.891]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:32.891]                   0L) {
[01:28:32.891]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:32.891]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:32.891]                   base::options(opts)
[01:28:32.891]                 }
[01:28:32.891]                 {
[01:28:32.891]                   {
[01:28:32.891]                     NULL
[01:28:32.891]                     RNGkind("Mersenne-Twister")
[01:28:32.891]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:32.891]                       inherits = FALSE)
[01:28:32.891]                   }
[01:28:32.891]                   options(future.plan = NULL)
[01:28:32.891]                   if (is.na(NA_character_)) 
[01:28:32.891]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:32.891]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:32.891]                   future::plan(list(a = function (..., envir = parent.frame()) 
[01:28:32.891]                   {
[01:28:32.891]                     future <- SequentialFuture(..., envir = envir)
[01:28:32.891]                     if (!future$lazy) 
[01:28:32.891]                       future <- run(future)
[01:28:32.891]                     invisible(future)
[01:28:32.891]                   }, b = function (..., workers = availableCores(), 
[01:28:32.891]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:32.891]                     envir = parent.frame()) 
[01:28:32.891]                   {
[01:28:32.891]                     if (is.function(workers)) 
[01:28:32.891]                       workers <- workers()
[01:28:32.891]                     workers <- structure(as.integer(workers), 
[01:28:32.891]                       class = class(workers))
[01:28:32.891]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:32.891]                       workers >= 1)
[01:28:32.891]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:32.891]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:32.891]                     }
[01:28:32.891]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:32.891]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:32.891]                       envir = envir)
[01:28:32.891]                     if (!future$lazy) 
[01:28:32.891]                       future <- run(future)
[01:28:32.891]                     invisible(future)
[01:28:32.891]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:32.891]                 }
[01:28:32.891]             }
[01:28:32.891]         }
[01:28:32.891]     })
[01:28:32.891]     if (TRUE) {
[01:28:32.891]         base::sink(type = "output", split = FALSE)
[01:28:32.891]         if (TRUE) {
[01:28:32.891]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:32.891]         }
[01:28:32.891]         else {
[01:28:32.891]             ...future.result["stdout"] <- base::list(NULL)
[01:28:32.891]         }
[01:28:32.891]         base::close(...future.stdout)
[01:28:32.891]         ...future.stdout <- NULL
[01:28:32.891]     }
[01:28:32.891]     ...future.result$conditions <- ...future.conditions
[01:28:32.891]     ...future.result$finished <- base::Sys.time()
[01:28:32.891]     ...future.result
[01:28:32.891] }
[01:28:32.895] assign_globals() ...
[01:28:32.896] List of 2
[01:28:32.896]  $ nested   :List of 2
[01:28:32.896]   ..$ a:function (..., envir = parent.frame())  
[01:28:32.896]   .. ..- attr(*, "class")= chr [1:4] "sequential" "uniprocess" "future" "function"
[01:28:32.896]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[01:28:32.896]   ..$ b:function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:32.896]     envir = parent.frame())  
[01:28:32.896]   .. ..- attr(*, "class")= chr [1:5] "multisession" "cluster" "multiprocess" "future" ...
[01:28:32.896]   .. ..- attr(*, "init")= logi TRUE
[01:28:32.896]   .. ..- attr(*, "untweakable")= chr "persistent"
[01:28:32.896]   .. ..- attr(*, "call")= language plan(list(a = strategy1, b = strategy2))
[01:28:32.896]   ..- attr(*, "class")= chr [1:2] "FutureStrategyList" "list"
[01:28:32.896]  $ strategy2: chr "multisession"
[01:28:32.896]  - attr(*, "where")=List of 2
[01:28:32.896]   ..$ nested   :<environment: R_EmptyEnv> 
[01:28:32.896]   ..$ strategy2:<environment: R_EmptyEnv> 
[01:28:32.896]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:32.896]  - attr(*, "resolved")= logi FALSE
[01:28:32.896]  - attr(*, "total_size")= num 56736
[01:28:32.896]  - attr(*, "already-done")= logi TRUE
[01:28:32.902] - copied 'nested' to environment
[01:28:32.903] - copied 'strategy2' to environment
[01:28:32.903] assign_globals() ... done
[01:28:32.903] plan(): Setting new future strategy stack:
[01:28:32.904] List of future strategies:
[01:28:32.904] 1. multisession:
[01:28:32.904]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:32.904]    - tweaked: FALSE
[01:28:32.904]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:32.906] plan(): nbrOfWorkers() = 2
[01:28:33.952] plan(): Setting new future strategy stack:
[01:28:33.952] List of future strategies:
[01:28:33.952] 1. sequential:
[01:28:33.952]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:33.952]    - tweaked: FALSE
[01:28:33.952]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:33.952] 2. multisession:
[01:28:33.952]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:33.952]    - tweaked: FALSE
[01:28:33.952]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:33.954] plan(): nbrOfWorkers() = 1
[01:28:33.954] SequentialFuture started (and completed)
[01:28:33.955] signalConditions() ...
[01:28:33.955]  - include = 'immediateCondition'
[01:28:33.955]  - exclude = 
[01:28:33.955]  - resignal = FALSE
[01:28:33.955]  - Number of conditions: 98
[01:28:33.956] signalConditions() ... done
[01:28:33.956] - Launch lazy future ... done
[01:28:33.956] run() for 'SequentialFuture' ... done
[01:28:33.956] signalConditions() ...
[01:28:33.957]  - include = 'immediateCondition'
[01:28:33.957]  - exclude = 
[01:28:33.957]  - resignal = FALSE
[01:28:33.957]  - Number of conditions: 98
[01:28:33.958] signalConditions() ... done
[01:28:33.958] Future state: 'finished'
[01:28:33.958] signalConditions() ...
[01:28:33.958]  - include = 'condition'
[01:28:33.958]  - exclude = 'immediateCondition'
[01:28:33.959]  - resignal = TRUE
[01:28:33.959]  - Number of conditions: 98
[01:28:33.959]  - Condition #1: 'simpleMessage', 'message', 'condition'
[01:28:32.908] getGlobalsAndPackages() ...
[01:28:33.959]  - Condition #2: 'simpleMessage', 'message', 'condition'
[01:28:32.908] Searching for globals...
[01:28:33.959]  - Condition #3: 'simpleMessage', 'message', 'condition'
[01:28:32.933] - globals found: [14] '{', '<-', '::', '[', 'nested_a', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'list', 'a', 'plan_a'
[01:28:33.960]  - Condition #4: 'simpleMessage', 'message', 'condition'
[01:28:32.933] Searching for globals ... DONE
[01:28:33.960]  - Condition #5: 'simpleMessage', 'message', 'condition'
[01:28:32.933] Resolving globals: FALSE
[01:28:33.960]  - Condition #6: 'simpleMessage', 'message', 'condition'
[01:28:32.934] The total size of the 3 globals is 87.82 KiB (89928 bytes)
[01:28:33.961]  - Condition #7: 'simpleMessage', 'message', 'condition'
[01:28:32.935] 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 87.82 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are three globals: 'nested_a' (43.88 KiB of class 'list'), 'plan_a' (43.88 KiB of class 'list') and 'a' (56 bytes of class 'numeric')
[01:28:33.961]  - Condition #8: 'simpleMessage', 'message', 'condition'
[01:28:32.935] - globals: [3] 'nested_a', 'a', 'plan_a'
[01:28:33.961]  - Condition #9: 'simpleMessage', 'message', 'condition'
[01:28:32.935] 
[01:28:33.962]  - Condition #10: 'simpleMessage', 'message', 'condition'
[01:28:32.935] getGlobalsAndPackages() ... DONE
[01:28:33.962]  - Condition #11: 'simpleMessage', 'message', 'condition'
[01:28:32.936] run() for 'Future' ...
[01:28:33.963]  - Condition #12: 'simpleMessage', 'message', 'condition'
[01:28:32.936] - state: 'created'
[01:28:33.963]  - Condition #13: 'simpleMessage', 'message', 'condition'
[01:28:32.936] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:33.963]  - Condition #14: 'simpleMessage', 'message', 'condition'
[01:28:32.941] [local output] makeClusterPSOCK() ...
[01:28:33.964]  - Condition #15: 'simpleMessage', 'message', 'condition'
[01:28:33.041] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:33.964]  - Condition #16: 'simpleMessage', 'message', 'condition'
[01:28:33.047] [local output] Base port: 29624
[01:28:33.964]  - Condition #17: 'simpleMessage', 'message', 'condition'
[01:28:33.047] [local output] Getting setup options for 2 cluster nodes ...
[01:28:33.965]  - Condition #18: 'simpleMessage', 'message', 'condition'
[01:28:33.048] [local output]  - Node 1 of 2 ...
[01:28:33.965]  - Condition #19: 'simpleMessage', 'message', 'condition'
[01:28:33.048] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:33.965]  - Condition #20: 'simpleMessage', 'message', 'condition'
[01:28:33.050] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.222036481ee5.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.222036481ee5.pid\")"'
[01:28:33.965]  - Condition #21: 'simpleMessage', 'message', 'condition'
[01:28:33.497] - Possible to infer worker's PID: TRUE
[01:28:33.966]  - Condition #22: 'simpleMessage', 'message', 'condition'
[01:28:33.498] [local output] Rscript port: 29624

[01:28:33.966]  - Condition #23: 'simpleMessage', 'message', 'condition'
[01:28:33.499] [local output]  - Node 2 of 2 ...
[01:28:33.966]  - Condition #24: 'simpleMessage', 'message', 'condition'
[01:28:33.500] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:33.967]  - Condition #25: 'simpleMessage', 'message', 'condition'
[01:28:33.501] [local output] Rscript port: 29624

[01:28:33.967]  - Condition #26: 'simpleMessage', 'message', 'condition'
[01:28:33.502] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:33.967]  - Condition #27: 'simpleMessage', 'message', 'condition'
[01:28:33.502] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:33.967]  - Condition #28: 'simpleMessage', 'message', 'condition'
[01:28:33.503] [local output] Setting up PSOCK nodes in parallel
[01:28:33.968]  - Condition #29: 'simpleMessage', 'message', 'condition'
[01:28:33.503] List of 36
[01:28:33.503]  $ worker          : chr "localhost"
[01:28:33.503]   ..- attr(*, "localhost")= logi TRUE
[01:28:33.503]  $ master          : chr "localhost"
[01:28:33.503]  $ port            : int 29624
[01:28:33.503]  $ connectTimeout  : num 120
[01:28:33.503]  $ timeout         : num 120
[01:28:33.503]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:33.503]  $ homogeneous     : logi TRUE
[01:28:33.503]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=nested_futures.R:8736:CRANWIN3:C"| __truncated__
[01:28:33.503]  $ rscript_envs    : NULL
[01:28:33.503]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:33.503]  $ rscript_startup : NULL
[01:28:33.503]  $ rscript_sh      : chr "cmd"
[01:28:33.503]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:33.503]  $ methods         : logi TRUE
[01:28:33.503]  $ socketOptions   : chr "no-delay"
[01:28:33.503]  $ useXDR          : logi FALSE
[01:28:33.503]  $ outfile         : chr "/dev/null"
[01:28:33.503]  $ renice          : int NA
[01:28:33.503]  $ rshcmd          : NULL
[01:28:33.503]  $ user            : chr(0) 
[01:28:33.503]  $ revtunnel       : logi FALSE
[01:28:33.503]  $ rshlogfile      : NULL
[01:28:33.503]  $ rshopts         : chr(0) 
[01:28:33.503]  $ rank            : int 1
[01:28:33.503]  $ manual          : logi FALSE
[01:28:33.503]  $ dryrun          : logi FALSE
[01:28:33.503]  $ quiet           : logi FALSE
[01:28:33.503]  $ setup_strategy  : chr "parallel"
[01:28:33.503]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:33.503]  $ pidfile         : chr "D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.222036481ee5.pid"
[01:28:33.503]  $ rshcmd_label    : NULL
[01:28:33.503]  $ rsh_call        : NULL
[01:28:33.503]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:33.503]  $ localMachine    : logi TRUE
[01:28:33.503]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:33.503]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:33.503]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:33.503]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:33.503]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:33.503]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:33.503]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:33.503]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:33.503]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:33.503]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:33.503]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:33.503]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:33.503]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:33.503]  $ arguments       :List of 28
[01:28:33.503]   ..$ worker          : chr "localhost"
[01:28:33.503]   ..$ master          : NULL
[01:28:33.503]   ..$ port            : int 29624
[01:28:33.503]   ..$ connectTimeout  : num 120
[01:28:33.503]   ..$ timeout         : num 120
[01:28:33.503]   ..$ rscript         : NULL
[01:28:33.503]   ..$ homogeneous     : NULL
[01:28:33.503]   ..$ rscript_args    : NULL
[01:28:33.503]   ..$ rscript_envs    : NULL
[01:28:33.503]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:33.503]   ..$ rscript_startup : NULL
[01:28:33.503]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:33.503]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:33.503]   ..$ methods         : logi TRUE
[01:28:33.503]   ..$ socketOptions   : chr "no-delay"
[01:28:33.503]   ..$ useXDR          : logi FALSE
[01:28:33.503]   ..$ outfile         : chr "/dev/null"
[01:28:33.503]   ..$ renice          : int NA
[01:28:33.503]   ..$ rshcmd          : NULL
[01:28:33.503]   ..$ user            : NULL
[01:28:33.503]   ..$ revtunnel       : logi NA
[01:28:33.503]   ..$ rshlogfile      : NULL
[01:28:33.503]   ..$ rshopts         : NULL
[01:28:33.503]   ..$ rank            : int 1
[01:28:33.503]   ..$ manual          : logi FALSE
[01:28:33.503]   ..$ dryrun          : logi FALSE
[01:28:33.503]   ..$ quiet           : logi FALSE
[01:28:33.503]   ..$ setup_strategy  : chr "parallel"
[01:28:33.503]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:33.968]  - Condition #30: 'simpleMessage', 'message', 'condition'
[01:28:33.535] [local output] System call to launch all workers:
[01:28:33.968]  - Condition #31: 'simpleMessage', 'message', 'condition'
[01:28:33.536] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=nested_futures.R:8736:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.222036481ee5.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=29624 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:33.969]  - Condition #32: 'simpleMessage', 'message', 'condition'
[01:28:33.536] [local output] Starting PSOCK main server
[01:28:33.969]  - Condition #33: 'simpleMessage', 'message', 'condition'
[01:28:33.544] [local output] Workers launched
[01:28:33.969]  - Condition #34: 'simpleMessage', 'message', 'condition'
[01:28:33.544] [local output] Waiting for workers to connect back
[01:28:33.969]  - Condition #35: 'simpleMessage', 'message', 'condition'
[01:28:33.544]  - [local output] 0 workers out of 2 ready
[01:28:33.970]  - Condition #36: 'simpleMessage', 'message', 'condition'
[01:28:33.742]  - [local output] 0 workers out of 2 ready
[01:28:33.970]  - Condition #37: 'simpleMessage', 'message', 'condition'
[01:28:33.743]  - [local output] 1 workers out of 2 ready
[01:28:33.970]  - Condition #38: 'simpleMessage', 'message', 'condition'
[01:28:33.759]  - [local output] 1 workers out of 2 ready
[01:28:33.971]  - Condition #39: 'simpleMessage', 'message', 'condition'
[01:28:33.759]  - [local output] 2 workers out of 2 ready
[01:28:33.971]  - Condition #40: 'simpleMessage', 'message', 'condition'
[01:28:33.760] [local output] Launching of workers completed
[01:28:33.971]  - Condition #41: 'simpleMessage', 'message', 'condition'
[01:28:33.760] [local output] Collecting session information from workers
[01:28:33.971]  - Condition #42: 'simpleMessage', 'message', 'condition'
[01:28:33.761] [local output]  - Worker #1 of 2
[01:28:33.972]  - Condition #43: 'simpleMessage', 'message', 'condition'
[01:28:33.762] [local output]  - Worker #2 of 2
[01:28:33.972]  - Condition #44: 'simpleMessage', 'message', 'condition'
[01:28:33.762] [local output] makeClusterPSOCK() ... done
[01:28:33.972]  - Condition #45: 'simpleMessage', 'message', 'condition'
[01:28:33.775] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:33.972]  - Condition #46: 'simpleMessage', 'message', 'condition'
[01:28:33.775] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:33.973]  - Condition #47: 'simpleMessage', 'message', 'condition'
[01:28:33.776]   - Field: 'node'
[01:28:33.973]  - Condition #48: 'simpleMessage', 'message', 'condition'
[01:28:33.776]   - Field: 'label'
[01:28:33.973]  - Condition #49: 'simpleMessage', 'message', 'condition'
[01:28:33.776]   - Field: 'local'
[01:28:33.974]  - Condition #50: 'simpleMessage', 'message', 'condition'
[01:28:33.776]   - Field: 'owner'
[01:28:33.974]  - Condition #51: 'simpleMessage', 'message', 'condition'
[01:28:33.777]   - Field: 'envir'
[01:28:33.974]  - Condition #52: 'simpleMessage', 'message', 'condition'
[01:28:33.777]   - Field: 'workers'
[01:28:33.974]  - Condition #53: 'simpleMessage', 'message', 'condition'
[01:28:33.777]   - Field: 'packages'
[01:28:33.975]  - Condition #54: 'simpleMessage', 'message', 'condition'
[01:28:33.777]   - Field: 'gc'
[01:28:33.975]  - Condition #55: 'simpleMessage', 'message', 'condition'
[01:28:33.778]   - Field: 'conditions'
[01:28:33.975]  - Condition #56: 'simpleMessage', 'message', 'condition'
[01:28:33.778]   - Field: 'persistent'
[01:28:33.975]  - Condition #57: 'simpleMessage', 'message', 'condition'
[01:28:33.778]   - Field: 'expr'
[01:28:33.976]  - Condition #58: 'simpleMessage', 'message', 'condition'
[01:28:33.779]   - Field: 'uuid'
[01:28:33.976]  - Condition #59: 'simpleMessage', 'message', 'condition'
[01:28:33.779]   - Field: 'seed'
[01:28:33.976]  - Condition #60: 'simpleMessage', 'message', 'condition'
[01:28:33.779]   - Field: 'version'
[01:28:33.977]  - Condition #61: 'simpleMessage', 'message', 'condition'
[01:28:33.779]   - Field: 'result'
[01:28:33.977]  - Condition #62: 'simpleMessage', 'message', 'condition'
[01:28:33.780]   - Field: 'asynchronous'
[01:28:33.977]  - Condition #63: 'simpleMessage', 'message', 'condition'
[01:28:33.780]   - Field: 'calls'
[01:28:33.977]  - Condition #64: 'simpleMessage', 'message', 'condition'
[01:28:33.780]   - Field: 'globals'
[01:28:33.978]  - Condition #65: 'simpleMessage', 'message', 'condition'
[01:28:33.780]   - Field: 'stdout'
[01:28:33.978]  - Condition #66: 'simpleMessage', 'message', 'condition'
[01:28:33.781]   - Field: 'earlySignal'
[01:28:33.978]  - Condition #67: 'simpleMessage', 'message', 'condition'
[01:28:33.781]   - Field: 'lazy'
[01:28:33.979]  - Condition #68: 'simpleMessage', 'message', 'condition'
[01:28:33.781]   - Field: 'state'
[01:28:33.979]  - Condition #69: 'simpleMessage', 'message', 'condition'
[01:28:33.781] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:33.979]  - Condition #70: 'simpleMessage', 'message', 'condition'
[01:28:33.782] - Launch lazy future ...
[01:28:33.979]  - Condition #71: 'simpleMessage', 'message', 'condition'
[01:28:33.783] Packages needed by the future expression (n = 0): <none>
[01:28:33.980]  - Condition #72: 'simpleMessage', 'message', 'condition'
[01:28:33.783] Packages needed by future strategies (n = 0): <none>
[01:28:33.980]  - Condition #73: 'simpleMessage', 'message', 'condition'
[01:28:33.784] {
[01:28:33.784]     {
[01:28:33.784]         {
[01:28:33.784]             ...future.startTime <- base::Sys.time()
[01:28:33.784]             {
[01:28:33.784]                 {
[01:28:33.784]                   {
[01:28:33.784]                     {
[01:28:33.784]                       base::local({
[01:28:33.784]                         has_future <- base::requireNamespace("future", 
[01:28:33.784]                           quietly = TRUE)
[01:28:33.784]                         if (has_future) {
[01:28:33.784]                           ns <- base::getNamespace("future")
[01:28:33.784]                           version <- ns[[".package"]][["version"]]
[01:28:33.784]                           if (is.null(version)) 
[01:28:33.784]                             version <- utils::packageVersion("future")
[01:28:33.784]                         }
[01:28:33.784]                         else {
[01:28:33.784]                           version <- NULL
[01:28:33.784]                         }
[01:28:33.784]                         if (!has_future || version < "1.8.0") {
[01:28:33.784]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:33.784]                             "", base::R.version$version.string), 
[01:28:33.784]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:33.784]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:33.784]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:33.784]                               "release", "version")], collapse = " "), 
[01:28:33.784]                             hostname = base::Sys.info()[["nodename"]])
[01:28:33.784]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:33.784]                             info)
[01:28:33.784]                           info <- base::paste(info, collapse = "; ")
[01:28:33.784]                           if (!has_future) {
[01:28:33.784]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:33.784]                               info)
[01:28:33.784]                           }
[01:28:33.784]                           else {
[01:28:33.784]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:33.784]                               info, version)
[01:28:33.784]                           }
[01:28:33.784]                           base::stop(msg)
[01:28:33.784]                         }
[01:28:33.784]                       })
[01:28:33.784]                     }
[01:28:33.784]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:33.784]                     base::options(mc.cores = 1L)
[01:28:33.784]                   }
[01:28:33.784]                   options(future.plan = NULL)
[01:28:33.784]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:33.784]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:33.784]                 }
[01:28:33.784]                 ...future.workdir <- getwd()
[01:28:33.784]             }
[01:28:33.784]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:33.784]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:33.784]         }
[01:28:33.784]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:33.784]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:33.784]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:33.784]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:33.784]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:33.784]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:33.784]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:33.784]             base::names(...future.oldOptions))
[01:28:33.784]     }
[01:28:33.784]     if (FALSE) {
[01:28:33.784]     }
[01:28:33.784]     else {
[01:28:33.784]         if (TRUE) {
[01:28:33.784]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:33.784]                 open = "w")
[01:28:33.784]         }
[01:28:33.784]         else {
[01:28:33.784]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:33.784]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:33.784]         }
[01:28:33.784]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:33.784]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:33.784]             base::sink(type = "output", split = FALSE)
[01:28:33.784]             base::close(...future.stdout)
[01:28:33.784]         }, add = TRUE)
[01:28:33.784]     }
[01:28:33.784]     ...future.frame <- base::sys.nframe()
[01:28:33.784]     ...future.conditions <- base::list()
[01:28:33.784]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:33.784]     if (FALSE) {
[01:28:33.784]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:33.784]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:33.784]     }
[01:28:33.784]     ...future.result <- base::tryCatch({
[01:28:33.784]         base::withCallingHandlers({
[01:28:33.784]             ...future.value <- base::withVisible(base::local({
[01:28:33.784]                 ...future.makeSendCondition <- base::local({
[01:28:33.784]                   sendCondition <- NULL
[01:28:33.784]                   function(frame = 1L) {
[01:28:33.784]                     if (is.function(sendCondition)) 
[01:28:33.784]                       return(sendCondition)
[01:28:33.784]                     ns <- getNamespace("parallel")
[01:28:33.784]                     if (exists("sendData", mode = "function", 
[01:28:33.784]                       envir = ns)) {
[01:28:33.784]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:33.784]                         envir = ns)
[01:28:33.784]                       envir <- sys.frame(frame)
[01:28:33.784]                       master <- NULL
[01:28:33.784]                       while (!identical(envir, .GlobalEnv) && 
[01:28:33.784]                         !identical(envir, emptyenv())) {
[01:28:33.784]                         if (exists("master", mode = "list", envir = envir, 
[01:28:33.784]                           inherits = FALSE)) {
[01:28:33.784]                           master <- get("master", mode = "list", 
[01:28:33.784]                             envir = envir, inherits = FALSE)
[01:28:33.784]                           if (inherits(master, c("SOCKnode", 
[01:28:33.784]                             "SOCK0node"))) {
[01:28:33.784]                             sendCondition <<- function(cond) {
[01:28:33.784]                               data <- list(type = "VALUE", value = cond, 
[01:28:33.784]                                 success = TRUE)
[01:28:33.784]                               parallel_sendData(master, data)
[01:28:33.784]                             }
[01:28:33.784]                             return(sendCondition)
[01:28:33.784]                           }
[01:28:33.784]                         }
[01:28:33.784]                         frame <- frame + 1L
[01:28:33.784]                         envir <- sys.frame(frame)
[01:28:33.784]                       }
[01:28:33.784]                     }
[01:28:33.784]                     sendCondition <<- function(cond) NULL
[01:28:33.784]                   }
[01:28:33.784]                 })
[01:28:33.784]                 withCallingHandlers({
[01:28:33.784]                   {
[01:28:33.784]                     b <- 2L
[01:28:33.784]                     plan_b <- future::plan("list")
[01:28:33.784]                     nested_b <- nested_a[-1]
[01:28:33.784]                     stopifnot(length(nested_b) == 0L, length(plan_b) == 
[01:28:33.784]                       1L, inherits(plan_b[[1]], "future"), inherits(future::plan("next"), 
[01:28:33.784]                       "sequential"))
[01:28:33.784]                     list(a = a, nested_a = nested_a, plan_a = plan_a, 
[01:28:33.784]                       b = b, nested_b = nested_b, plan_b = plan_b)
[01:28:33.784]                   }
[01:28:33.784]                 }, immediateCondition = function(cond) {
[01:28:33.784]                   sendCondition <- ...future.makeSendCondition()
[01:28:33.784]                   sendCondition(cond)
[01:28:33.784]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:33.784]                   {
[01:28:33.784]                     inherits <- base::inherits
[01:28:33.784]                     invokeRestart <- base::invokeRestart
[01:28:33.784]                     is.null <- base::is.null
[01:28:33.784]                     muffled <- FALSE
[01:28:33.784]                     if (inherits(cond, "message")) {
[01:28:33.784]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:33.784]                       if (muffled) 
[01:28:33.784]                         invokeRestart("muffleMessage")
[01:28:33.784]                     }
[01:28:33.784]                     else if (inherits(cond, "warning")) {
[01:28:33.784]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:33.784]                       if (muffled) 
[01:28:33.784]                         invokeRestart("muffleWarning")
[01:28:33.784]                     }
[01:28:33.784]                     else if (inherits(cond, "condition")) {
[01:28:33.784]                       if (!is.null(pattern)) {
[01:28:33.784]                         computeRestarts <- base::computeRestarts
[01:28:33.784]                         grepl <- base::grepl
[01:28:33.784]                         restarts <- computeRestarts(cond)
[01:28:33.784]                         for (restart in restarts) {
[01:28:33.784]                           name <- restart$name
[01:28:33.784]                           if (is.null(name)) 
[01:28:33.784]                             next
[01:28:33.784]                           if (!grepl(pattern, name)) 
[01:28:33.784]                             next
[01:28:33.784]                           invokeRestart(restart)
[01:28:33.784]                           muffled <- TRUE
[01:28:33.784]                           break
[01:28:33.784]                         }
[01:28:33.784]                       }
[01:28:33.784]                     }
[01:28:33.784]                     invisible(muffled)
[01:28:33.784]                   }
[01:28:33.784]                   muffleCondition(cond)
[01:28:33.784]                 })
[01:28:33.784]             }))
[01:28:33.784]             future::FutureResult(value = ...future.value$value, 
[01:28:33.784]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:33.784]                   ...future.rng), globalenv = if (FALSE) 
[01:28:33.784]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:33.784]                     ...future.globalenv.names))
[01:28:33.784]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:33.784]         }, condition = base::local({
[01:28:33.784]             c <- base::c
[01:28:33.784]             inherits <- base::inherits
[01:28:33.784]             invokeRestart <- base::invokeRestart
[01:28:33.784]             length <- base::length
[01:28:33.784]             list <- base::list
[01:28:33.784]             seq.int <- base::seq.int
[01:28:33.784]             signalCondition <- base::signalCondition
[01:28:33.784]             sys.calls <- base::sys.calls
[01:28:33.784]             `[[` <- base::`[[`
[01:28:33.784]             `+` <- base::`+`
[01:28:33.784]             `<<-` <- base::`<<-`
[01:28:33.784]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:33.784]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:33.784]                   3L)]
[01:28:33.784]             }
[01:28:33.784]             function(cond) {
[01:28:33.784]                 is_error <- inherits(cond, "error")
[01:28:33.784]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:33.784]                   NULL)
[01:28:33.784]                 if (is_error) {
[01:28:33.784]                   sessionInformation <- function() {
[01:28:33.784]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:33.784]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:33.784]                       search = base::search(), system = base::Sys.info())
[01:28:33.784]                   }
[01:28:33.784]                   ...future.conditions[[length(...future.conditions) + 
[01:28:33.784]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:33.784]                     cond$call), session = sessionInformation(), 
[01:28:33.784]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:33.784]                   signalCondition(cond)
[01:28:33.784]                 }
[01:28:33.784]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:33.784]                 "immediateCondition"))) {
[01:28:33.784]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:33.784]                   ...future.conditions[[length(...future.conditions) + 
[01:28:33.784]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:33.784]                   if (TRUE && !signal) {
[01:28:33.784]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:33.784]                     {
[01:28:33.784]                       inherits <- base::inherits
[01:28:33.784]                       invokeRestart <- base::invokeRestart
[01:28:33.784]                       is.null <- base::is.null
[01:28:33.784]                       muffled <- FALSE
[01:28:33.784]                       if (inherits(cond, "message")) {
[01:28:33.784]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:33.784]                         if (muffled) 
[01:28:33.784]                           invokeRestart("muffleMessage")
[01:28:33.784]                       }
[01:28:33.784]                       else if (inherits(cond, "warning")) {
[01:28:33.784]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:33.784]                         if (muffled) 
[01:28:33.784]                           invokeRestart("muffleWarning")
[01:28:33.784]                       }
[01:28:33.784]                       else if (inherits(cond, "condition")) {
[01:28:33.784]                         if (!is.null(pattern)) {
[01:28:33.784]                           computeRestarts <- base::computeRestarts
[01:28:33.784]                           grepl <- base::grepl
[01:28:33.784]                           restarts <- computeRestarts(cond)
[01:28:33.784]                           for (restart in restarts) {
[01:28:33.784]                             name <- restart$name
[01:28:33.784]                             if (is.null(name)) 
[01:28:33.784]                               next
[01:28:33.784]                             if (!grepl(pattern, name)) 
[01:28:33.784]                               next
[01:28:33.784]                             invokeRestart(restart)
[01:28:33.784]                             muffled <- TRUE
[01:28:33.784]                             break
[01:28:33.784]                           }
[01:28:33.784]                         }
[01:28:33.784]                       }
[01:28:33.784]                       invisible(muffled)
[01:28:33.784]                     }
[01:28:33.784]                     muffleCondition(cond, pattern = "^muffle")
[01:28:33.784]                   }
[01:28:33.784]                 }
[01:28:33.784]                 else {
[01:28:33.784]                   if (TRUE) {
[01:28:33.784]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:33.784]                     {
[01:28:33.784]                       inherits <- base::inherits
[01:28:33.784]                       invokeRestart <- base::invokeRestart
[01:28:33.784]                       is.null <- base::is.null
[01:28:33.784]                       muffled <- FALSE
[01:28:33.784]                       if (inherits(cond, "message")) {
[01:28:33.784]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:33.784]                         if (muffled) 
[01:28:33.784]                           invokeRestart("muffleMessage")
[01:28:33.784]                       }
[01:28:33.784]                       else if (inherits(cond, "warning")) {
[01:28:33.784]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:33.784]                         if (muffled) 
[01:28:33.784]                           invokeRestart("muffleWarning")
[01:28:33.784]                       }
[01:28:33.784]                       else if (inherits(cond, "condition")) {
[01:28:33.784]                         if (!is.null(pattern)) {
[01:28:33.784]                           computeRestarts <- base::computeRestarts
[01:28:33.784]                           grepl <- base::grepl
[01:28:33.784]                           restarts <- computeRestarts(cond)
[01:28:33.784]                           for (restart in restarts) {
[01:28:33.784]                             name <- restart$name
[01:28:33.784]                             if (is.null(name)) 
[01:28:33.784]                               next
[01:28:33.784]                             if (!grepl(pattern, name)) 
[01:28:33.784]                               next
[01:28:33.784]                             invokeRestart(restart)
[01:28:33.784]                             muffled <- TRUE
[01:28:33.784]                             break
[01:28:33.784]                           }
[01:28:33.784]                         }
[01:28:33.784]                       }
[01:28:33.784]                       invisible(muffled)
[01:28:33.784]                     }
[01:28:33.784]                     muffleCondition(cond, pattern = "^muffle")
[01:28:33.784]                   }
[01:28:33.784]                 }
[01:28:33.784]             }
[01:28:33.784]         }))
[01:28:33.784]     }, error = function(ex) {
[01:28:33.784]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:33.784]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:33.784]                 ...future.rng), started = ...future.startTime, 
[01:28:33.784]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:33.784]             version = "1.8"), class = "FutureResult")
[01:28:33.784]     }, finally = {
[01:28:33.784]         if (!identical(...future.workdir, getwd())) 
[01:28:33.784]             setwd(...future.workdir)
[01:28:33.784]         {
[01:28:33.784]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:33.784]                 ...future.oldOptions$nwarnings <- NULL
[01:28:33.784]             }
[01:28:33.784]             base::options(...future.oldOptions)
[01:28:33.784]             if (.Platform$OS.type == "windows") {
[01:28:33.784]                 old_names <- names(...future.oldEnvVars)
[01:28:33.784]                 envs <- base::Sys.getenv()
[01:28:33.784]                 names <- names(envs)
[01:28:33.784]                 common <- intersect(names, old_names)
[01:28:33.784]                 added <- setdiff(names, old_names)
[01:28:33.784]                 removed <- setdiff(old_names, names)
[01:28:33.784]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:33.784]                   envs[common]]
[01:28:33.784]                 NAMES <- toupper(changed)
[01:28:33.784]                 args <- list()
[01:28:33.784]                 for (kk in seq_along(NAMES)) {
[01:28:33.784]                   name <- changed[[kk]]
[01:28:33.784]                   NAME <- NAMES[[kk]]
[01:28:33.784]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:33.784]                     next
[01:28:33.784]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:33.784]                 }
[01:28:33.784]                 NAMES <- toupper(added)
[01:28:33.784]                 for (kk in seq_along(NAMES)) {
[01:28:33.784]                   name <- added[[kk]]
[01:28:33.784]                   NAME <- NAMES[[kk]]
[01:28:33.784]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:33.784]                     next
[01:28:33.784]                   args[[name]] <- ""
[01:28:33.784]                 }
[01:28:33.784]                 NAMES <- toupper(removed)
[01:28:33.784]                 for (kk in seq_along(NAMES)) {
[01:28:33.784]                   name <- removed[[kk]]
[01:28:33.784]                   NAME <- NAMES[[kk]]
[01:28:33.784]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:33.784]                     next
[01:28:33.784]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:33.784]                 }
[01:28:33.784]                 if (length(args) > 0) 
[01:28:33.784]                   base::do.call(base::Sys.setenv, args = args)
[01:28:33.784]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:33.784]             }
[01:28:33.784]             else {
[01:28:33.784]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:33.784]             }
[01:28:33.784]             {
[01:28:33.784]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:33.784]                   0L) {
[01:28:33.784]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:33.784]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:33.784]                   base::options(opts)
[01:28:33.784]                 }
[01:28:33.784]                 {
[01:28:33.784]                   {
[01:28:33.784]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:33.784]                     NULL
[01:28:33.784]                   }
[01:28:33.784]                   options(future.plan = NULL)
[01:28:33.784]                   if (is.na(NA_character_)) 
[01:28:33.784]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:33.784]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:33.784]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:33.784]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:33.784]                     envir = parent.frame()) 
[01:28:33.784]                   {
[01:28:33.784]                     if (is.function(workers)) 
[01:28:33.784]                       workers <- workers()
[01:28:33.784]                     workers <- structure(as.integer(workers), 
[01:28:33.784]                       class = class(workers))
[01:28:33.784]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:33.784]                       workers >= 1)
[01:28:33.784]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:33.784]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:33.784]                     }
[01:28:33.784]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:33.784]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:33.784]                       envir = envir)
[01:28:33.784]                     if (!future$lazy) 
[01:28:33.784]                       future <- run(future)
[01:28:33.784]                     invisible(future)
[01:28:33.784]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:33.784]                 }
[01:28:33.784]             }
[01:28:33.784]         }
[01:28:33.784]     })
[01:28:33.784]     if (TRUE) {
[01:28:33.784]         base::sink(type = "output", split = FALSE)
[01:28:33.784]         if (TRUE) {
[01:28:33.784]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:33.784]         }
[01:28:33.784]         else {
[01:28:33.784]             ...future.result["stdout"] <- base::list(NULL)
[01:28:33.784]         }
[01:28:33.784]         base::close(...future.stdout)
[01:28:33.784]         ...future.stdout <- NULL
[01:28:33.784]     }
[01:28:33.784]     ...future.result$conditions <- ...future.conditions
[01:28:33.784]     ...future.result$finished <- base::Sys.time()
[01:28:33.784]     ...future.result
[01:28:33.784] }
[01:28:33.981]  - Condition #74: 'simpleMessage', 'message', 'condition'
[01:28:33.875] Exporting 3 global objects (87.82 KiB) to cluster node #1 ...
[01:28:33.981]  - Condition #75: 'simpleMessage', 'message', 'condition'
[01:28:33.875] Exporting 'nested_a' (43.88 KiB) to cluster node #1 ...
[01:28:33.981]  - Condition #76: 'simpleMessage', 'message', 'condition'
[01:28:33.876] Exporting 'nested_a' (43.88 KiB) to cluster node #1 ... DONE
[01:28:33.982]  - Condition #77: 'simpleMessage', 'message', 'condition'
[01:28:33.876] Exporting 'a' (56 bytes) to cluster node #1 ...
[01:28:33.982]  - Condition #78: 'simpleMessage', 'message', 'condition'
[01:28:33.877] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[01:28:33.983]  - Condition #79: 'simpleMessage', 'message', 'condition'
[01:28:33.877] Exporting 'plan_a' (43.88 KiB) to cluster node #1 ...
[01:28:33.983]  - Condition #80: 'simpleMessage', 'message', 'condition'
[01:28:33.878] Exporting 'plan_a' (43.88 KiB) to cluster node #1 ... DONE
[01:28:33.984]  - Condition #81: 'simpleMessage', 'message', 'condition'
[01:28:33.878] Exporting 3 global objects (87.82 KiB) to cluster node #1 ... DONE
[01:28:33.984]  - Condition #82: 'simpleMessage', 'message', 'condition'
[01:28:33.879] MultisessionFuture started
[01:28:33.984]  - Condition #83: 'simpleMessage', 'message', 'condition'
[01:28:33.879] - Launch lazy future ... done
[01:28:33.985]  - Condition #84: 'simpleMessage', 'message', 'condition'
[01:28:33.879] run() for 'MultisessionFuture' ... done
[01:28:33.985]  - Condition #85: 'simpleMessage', 'message', 'condition'
[01:28:33.880] result() for ClusterFuture ...
[01:28:33.986]  - Condition #86: 'simpleMessage', 'message', 'condition'
[01:28:33.880] receiveMessageFromWorker() for ClusterFuture ...
[01:28:33.986]  - Condition #87: 'simpleMessage', 'message', 'condition'
[01:28:33.881] - Validating connection of MultisessionFuture
[01:28:33.986]  - Condition #88: 'simpleMessage', 'message', 'condition'
[01:28:33.944] - received message: FutureResult
[01:28:33.987]  - Condition #89: 'simpleMessage', 'message', 'condition'
[01:28:33.944] - Received FutureResult
[01:28:33.987]  - Condition #90: 'simpleMessage', 'message', 'condition'
[01:28:33.948] - Erased future from FutureRegistry
[01:28:33.988]  - Condition #91: 'simpleMessage', 'message', 'condition'
[01:28:33.948] result() for ClusterFuture ...
[01:28:33.988]  - Condition #92: 'simpleMessage', 'message', 'condition'
[01:28:33.949] - result already collected: FutureResult
[01:28:33.988]  - Condition #93: 'simpleMessage', 'message', 'condition'
[01:28:33.949] result() for ClusterFuture ... done
[01:28:33.989]  - Condition #94: 'simpleMessage', 'message', 'condition'
[01:28:33.949] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:33.989]  - Condition #95: 'simpleMessage', 'message', 'condition'
[01:28:33.949] result() for ClusterFuture ... done
[01:28:33.989]  - Condition #96: 'simpleMessage', 'message', 'condition'
[01:28:33.950] result() for ClusterFuture ...
[01:28:33.990]  - Condition #97: 'simpleMessage', 'message', 'condition'
[01:28:33.950] - result already collected: FutureResult
[01:28:33.990]  - Condition #98: 'simpleMessage', 'message', 'condition'
[01:28:33.950] result() for ClusterFuture ... done
[01:28:33.991] 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(*, "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(*, "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"
[01:28:34.003] getGlobalsAndPackages() ...
[01:28:34.003] Searching for globals...
[01:28:34.005] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[01:28:34.005] Searching for globals ... DONE
[01:28:34.006] Resolving globals: FALSE
[01:28:34.006] The total size of the 1 globals is 128 bytes (128 bytes)
[01:28:34.007] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 128 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (128 bytes of class 'list')
[01:28:34.007] - globals: [1] 'data'
[01:28:34.007] - packages: [1] 'future'
[01:28:34.008] getGlobalsAndPackages() ... DONE
[01:28:34.008] run() for 'Future' ...
[01:28:34.008] - state: 'created'
[01:28:34.009] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:34.009] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:34.009] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:34.009]   - Field: 'label'
[01:28:34.010]   - Field: 'local'
[01:28:34.010]   - Field: 'owner'
[01:28:34.010]   - Field: 'envir'
[01:28:34.010]   - Field: 'packages'
[01:28:34.010]   - Field: 'gc'
[01:28:34.011]   - Field: 'conditions'
[01:28:34.011]   - Field: 'expr'
[01:28:34.011]   - Field: 'uuid'
[01:28:34.011]   - Field: 'seed'
[01:28:34.011]   - Field: 'version'
[01:28:34.012]   - Field: 'result'
[01:28:34.012]   - Field: 'asynchronous'
[01:28:34.012]   - Field: 'calls'
[01:28:34.013]   - Field: 'globals'
[01:28:34.013]   - Field: 'stdout'
[01:28:34.013]   - Field: 'earlySignal'
[01:28:34.013]   - Field: 'lazy'
[01:28:34.013]   - Field: 'state'
[01:28:34.014] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:34.014] - Launch lazy future ...
[01:28:34.014] Packages needed by the future expression (n = 1): 'future'
[01:28:34.014] Packages needed by future strategies (n = 1): 'future'
[01:28:34.015] {
[01:28:34.015]     {
[01:28:34.015]         {
[01:28:34.015]             ...future.startTime <- base::Sys.time()
[01:28:34.015]             {
[01:28:34.015]                 {
[01:28:34.015]                   {
[01:28:34.015]                     {
[01:28:34.015]                       base::local({
[01:28:34.015]                         has_future <- base::requireNamespace("future", 
[01:28:34.015]                           quietly = TRUE)
[01:28:34.015]                         if (has_future) {
[01:28:34.015]                           ns <- base::getNamespace("future")
[01:28:34.015]                           version <- ns[[".package"]][["version"]]
[01:28:34.015]                           if (is.null(version)) 
[01:28:34.015]                             version <- utils::packageVersion("future")
[01:28:34.015]                         }
[01:28:34.015]                         else {
[01:28:34.015]                           version <- NULL
[01:28:34.015]                         }
[01:28:34.015]                         if (!has_future || version < "1.8.0") {
[01:28:34.015]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:34.015]                             "", base::R.version$version.string), 
[01:28:34.015]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:34.015]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:34.015]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:34.015]                               "release", "version")], collapse = " "), 
[01:28:34.015]                             hostname = base::Sys.info()[["nodename"]])
[01:28:34.015]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:34.015]                             info)
[01:28:34.015]                           info <- base::paste(info, collapse = "; ")
[01:28:34.015]                           if (!has_future) {
[01:28:34.015]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:34.015]                               info)
[01:28:34.015]                           }
[01:28:34.015]                           else {
[01:28:34.015]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:34.015]                               info, version)
[01:28:34.015]                           }
[01:28:34.015]                           base::stop(msg)
[01:28:34.015]                         }
[01:28:34.015]                       })
[01:28:34.015]                     }
[01:28:34.015]                     base::local({
[01:28:34.015]                       for (pkg in "future") {
[01:28:34.015]                         base::loadNamespace(pkg)
[01:28:34.015]                         base::library(pkg, character.only = TRUE)
[01:28:34.015]                       }
[01:28:34.015]                     })
[01:28:34.015]                   }
[01:28:34.015]                   options(future.plan = NULL)
[01:28:34.015]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.015]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:34.015]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:34.015]                     envir = parent.frame()) 
[01:28:34.015]                   {
[01:28:34.015]                     if (is.function(workers)) 
[01:28:34.015]                       workers <- workers()
[01:28:34.015]                     workers <- structure(as.integer(workers), 
[01:28:34.015]                       class = class(workers))
[01:28:34.015]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:34.015]                       workers >= 1)
[01:28:34.015]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:34.015]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:34.015]                     }
[01:28:34.015]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:34.015]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:34.015]                       envir = envir)
[01:28:34.015]                     if (!future$lazy) 
[01:28:34.015]                       future <- run(future)
[01:28:34.015]                     invisible(future)
[01:28:34.015]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.015]                 }
[01:28:34.015]                 ...future.workdir <- getwd()
[01:28:34.015]             }
[01:28:34.015]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:34.015]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:34.015]         }
[01:28:34.015]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:34.015]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:34.015]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:34.015]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:34.015]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:34.015]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:34.015]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:34.015]             base::names(...future.oldOptions))
[01:28:34.015]     }
[01:28:34.015]     if (FALSE) {
[01:28:34.015]     }
[01:28:34.015]     else {
[01:28:34.015]         if (TRUE) {
[01:28:34.015]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:34.015]                 open = "w")
[01:28:34.015]         }
[01:28:34.015]         else {
[01:28:34.015]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:34.015]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:34.015]         }
[01:28:34.015]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:34.015]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:34.015]             base::sink(type = "output", split = FALSE)
[01:28:34.015]             base::close(...future.stdout)
[01:28:34.015]         }, add = TRUE)
[01:28:34.015]     }
[01:28:34.015]     ...future.frame <- base::sys.nframe()
[01:28:34.015]     ...future.conditions <- base::list()
[01:28:34.015]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:34.015]     if (FALSE) {
[01:28:34.015]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:34.015]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:34.015]     }
[01:28:34.015]     ...future.result <- base::tryCatch({
[01:28:34.015]         base::withCallingHandlers({
[01:28:34.015]             ...future.value <- base::withVisible(base::local({
[01:28:34.015]                 value(future(subset(data, a == 2)))
[01:28:34.015]             }))
[01:28:34.015]             future::FutureResult(value = ...future.value$value, 
[01:28:34.015]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.015]                   ...future.rng), globalenv = if (FALSE) 
[01:28:34.015]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:34.015]                     ...future.globalenv.names))
[01:28:34.015]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:34.015]         }, condition = base::local({
[01:28:34.015]             c <- base::c
[01:28:34.015]             inherits <- base::inherits
[01:28:34.015]             invokeRestart <- base::invokeRestart
[01:28:34.015]             length <- base::length
[01:28:34.015]             list <- base::list
[01:28:34.015]             seq.int <- base::seq.int
[01:28:34.015]             signalCondition <- base::signalCondition
[01:28:34.015]             sys.calls <- base::sys.calls
[01:28:34.015]             `[[` <- base::`[[`
[01:28:34.015]             `+` <- base::`+`
[01:28:34.015]             `<<-` <- base::`<<-`
[01:28:34.015]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:34.015]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:34.015]                   3L)]
[01:28:34.015]             }
[01:28:34.015]             function(cond) {
[01:28:34.015]                 is_error <- inherits(cond, "error")
[01:28:34.015]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:34.015]                   NULL)
[01:28:34.015]                 if (is_error) {
[01:28:34.015]                   sessionInformation <- function() {
[01:28:34.015]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:34.015]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:34.015]                       search = base::search(), system = base::Sys.info())
[01:28:34.015]                   }
[01:28:34.015]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.015]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:34.015]                     cond$call), session = sessionInformation(), 
[01:28:34.015]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:34.015]                   signalCondition(cond)
[01:28:34.015]                 }
[01:28:34.015]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:34.015]                 "immediateCondition"))) {
[01:28:34.015]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:34.015]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.015]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:34.015]                   if (TRUE && !signal) {
[01:28:34.015]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.015]                     {
[01:28:34.015]                       inherits <- base::inherits
[01:28:34.015]                       invokeRestart <- base::invokeRestart
[01:28:34.015]                       is.null <- base::is.null
[01:28:34.015]                       muffled <- FALSE
[01:28:34.015]                       if (inherits(cond, "message")) {
[01:28:34.015]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.015]                         if (muffled) 
[01:28:34.015]                           invokeRestart("muffleMessage")
[01:28:34.015]                       }
[01:28:34.015]                       else if (inherits(cond, "warning")) {
[01:28:34.015]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.015]                         if (muffled) 
[01:28:34.015]                           invokeRestart("muffleWarning")
[01:28:34.015]                       }
[01:28:34.015]                       else if (inherits(cond, "condition")) {
[01:28:34.015]                         if (!is.null(pattern)) {
[01:28:34.015]                           computeRestarts <- base::computeRestarts
[01:28:34.015]                           grepl <- base::grepl
[01:28:34.015]                           restarts <- computeRestarts(cond)
[01:28:34.015]                           for (restart in restarts) {
[01:28:34.015]                             name <- restart$name
[01:28:34.015]                             if (is.null(name)) 
[01:28:34.015]                               next
[01:28:34.015]                             if (!grepl(pattern, name)) 
[01:28:34.015]                               next
[01:28:34.015]                             invokeRestart(restart)
[01:28:34.015]                             muffled <- TRUE
[01:28:34.015]                             break
[01:28:34.015]                           }
[01:28:34.015]                         }
[01:28:34.015]                       }
[01:28:34.015]                       invisible(muffled)
[01:28:34.015]                     }
[01:28:34.015]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.015]                   }
[01:28:34.015]                 }
[01:28:34.015]                 else {
[01:28:34.015]                   if (TRUE) {
[01:28:34.015]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.015]                     {
[01:28:34.015]                       inherits <- base::inherits
[01:28:34.015]                       invokeRestart <- base::invokeRestart
[01:28:34.015]                       is.null <- base::is.null
[01:28:34.015]                       muffled <- FALSE
[01:28:34.015]                       if (inherits(cond, "message")) {
[01:28:34.015]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.015]                         if (muffled) 
[01:28:34.015]                           invokeRestart("muffleMessage")
[01:28:34.015]                       }
[01:28:34.015]                       else if (inherits(cond, "warning")) {
[01:28:34.015]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.015]                         if (muffled) 
[01:28:34.015]                           invokeRestart("muffleWarning")
[01:28:34.015]                       }
[01:28:34.015]                       else if (inherits(cond, "condition")) {
[01:28:34.015]                         if (!is.null(pattern)) {
[01:28:34.015]                           computeRestarts <- base::computeRestarts
[01:28:34.015]                           grepl <- base::grepl
[01:28:34.015]                           restarts <- computeRestarts(cond)
[01:28:34.015]                           for (restart in restarts) {
[01:28:34.015]                             name <- restart$name
[01:28:34.015]                             if (is.null(name)) 
[01:28:34.015]                               next
[01:28:34.015]                             if (!grepl(pattern, name)) 
[01:28:34.015]                               next
[01:28:34.015]                             invokeRestart(restart)
[01:28:34.015]                             muffled <- TRUE
[01:28:34.015]                             break
[01:28:34.015]                           }
[01:28:34.015]                         }
[01:28:34.015]                       }
[01:28:34.015]                       invisible(muffled)
[01:28:34.015]                     }
[01:28:34.015]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.015]                   }
[01:28:34.015]                 }
[01:28:34.015]             }
[01:28:34.015]         }))
[01:28:34.015]     }, error = function(ex) {
[01:28:34.015]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:34.015]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.015]                 ...future.rng), started = ...future.startTime, 
[01:28:34.015]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:34.015]             version = "1.8"), class = "FutureResult")
[01:28:34.015]     }, finally = {
[01:28:34.015]         if (!identical(...future.workdir, getwd())) 
[01:28:34.015]             setwd(...future.workdir)
[01:28:34.015]         {
[01:28:34.015]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:34.015]                 ...future.oldOptions$nwarnings <- NULL
[01:28:34.015]             }
[01:28:34.015]             base::options(...future.oldOptions)
[01:28:34.015]             if (.Platform$OS.type == "windows") {
[01:28:34.015]                 old_names <- names(...future.oldEnvVars)
[01:28:34.015]                 envs <- base::Sys.getenv()
[01:28:34.015]                 names <- names(envs)
[01:28:34.015]                 common <- intersect(names, old_names)
[01:28:34.015]                 added <- setdiff(names, old_names)
[01:28:34.015]                 removed <- setdiff(old_names, names)
[01:28:34.015]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:34.015]                   envs[common]]
[01:28:34.015]                 NAMES <- toupper(changed)
[01:28:34.015]                 args <- list()
[01:28:34.015]                 for (kk in seq_along(NAMES)) {
[01:28:34.015]                   name <- changed[[kk]]
[01:28:34.015]                   NAME <- NAMES[[kk]]
[01:28:34.015]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.015]                     next
[01:28:34.015]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.015]                 }
[01:28:34.015]                 NAMES <- toupper(added)
[01:28:34.015]                 for (kk in seq_along(NAMES)) {
[01:28:34.015]                   name <- added[[kk]]
[01:28:34.015]                   NAME <- NAMES[[kk]]
[01:28:34.015]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.015]                     next
[01:28:34.015]                   args[[name]] <- ""
[01:28:34.015]                 }
[01:28:34.015]                 NAMES <- toupper(removed)
[01:28:34.015]                 for (kk in seq_along(NAMES)) {
[01:28:34.015]                   name <- removed[[kk]]
[01:28:34.015]                   NAME <- NAMES[[kk]]
[01:28:34.015]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.015]                     next
[01:28:34.015]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.015]                 }
[01:28:34.015]                 if (length(args) > 0) 
[01:28:34.015]                   base::do.call(base::Sys.setenv, args = args)
[01:28:34.015]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:34.015]             }
[01:28:34.015]             else {
[01:28:34.015]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:34.015]             }
[01:28:34.015]             {
[01:28:34.015]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:34.015]                   0L) {
[01:28:34.015]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:34.015]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:34.015]                   base::options(opts)
[01:28:34.015]                 }
[01:28:34.015]                 {
[01:28:34.015]                   {
[01:28:34.015]                     NULL
[01:28:34.015]                     RNGkind("Mersenne-Twister")
[01:28:34.015]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:34.015]                       inherits = FALSE)
[01:28:34.015]                   }
[01:28:34.015]                   options(future.plan = NULL)
[01:28:34.015]                   if (is.na(NA_character_)) 
[01:28:34.015]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.015]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:34.015]                   future::plan(list(a = function (..., envir = parent.frame()) 
[01:28:34.015]                   {
[01:28:34.015]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.015]                     if (!future$lazy) 
[01:28:34.015]                       future <- run(future)
[01:28:34.015]                     invisible(future)
[01:28:34.015]                   }, b = function (..., workers = availableCores(), 
[01:28:34.015]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:34.015]                     envir = parent.frame()) 
[01:28:34.015]                   {
[01:28:34.015]                     if (is.function(workers)) 
[01:28:34.015]                       workers <- workers()
[01:28:34.015]                     workers <- structure(as.integer(workers), 
[01:28:34.015]                       class = class(workers))
[01:28:34.015]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:34.015]                       workers >= 1)
[01:28:34.015]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:34.015]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:34.015]                     }
[01:28:34.015]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:34.015]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:34.015]                       envir = envir)
[01:28:34.015]                     if (!future$lazy) 
[01:28:34.015]                       future <- run(future)
[01:28:34.015]                     invisible(future)
[01:28:34.015]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.015]                 }
[01:28:34.015]             }
[01:28:34.015]         }
[01:28:34.015]     })
[01:28:34.015]     if (TRUE) {
[01:28:34.015]         base::sink(type = "output", split = FALSE)
[01:28:34.015]         if (TRUE) {
[01:28:34.015]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:34.015]         }
[01:28:34.015]         else {
[01:28:34.015]             ...future.result["stdout"] <- base::list(NULL)
[01:28:34.015]         }
[01:28:34.015]         base::close(...future.stdout)
[01:28:34.015]         ...future.stdout <- NULL
[01:28:34.015]     }
[01:28:34.015]     ...future.result$conditions <- ...future.conditions
[01:28:34.015]     ...future.result$finished <- base::Sys.time()
[01:28:34.015]     ...future.result
[01:28:34.015] }
[01:28:34.020] assign_globals() ...
[01:28:34.020] List of 1
[01:28:34.020]  $ data:'data.frame':	3 obs. of  2 variables:
[01:28:34.020]   ..$ a: int [1:3] 1 2 3
[01:28:34.020]   ..$ b: int [1:3] 3 2 1
[01:28:34.020]  - attr(*, "where")=List of 1
[01:28:34.020]   ..$ data:<environment: R_EmptyEnv> 
[01:28:34.020]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:34.020]  - attr(*, "resolved")= logi FALSE
[01:28:34.020]  - attr(*, "total_size")= num 128
[01:28:34.020]  - attr(*, "already-done")= logi TRUE
[01:28:34.026] - copied 'data' to environment
[01:28:34.027] assign_globals() ... done
[01:28:34.027] plan(): Setting new future strategy stack:
[01:28:34.027] List of future strategies:
[01:28:34.027] 1. multisession:
[01:28:34.027]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.027]    - tweaked: FALSE
[01:28:34.027]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.030] plan(): nbrOfWorkers() = 2
[01:28:34.104] plan(): Setting new future strategy stack:
[01:28:34.104] List of future strategies:
[01:28:34.104] 1. sequential:
[01:28:34.104]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:34.104]    - tweaked: FALSE
[01:28:34.104]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.104] 2. multisession:
[01:28:34.104]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.104]    - tweaked: FALSE
[01:28:34.104]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.105] plan(): nbrOfWorkers() = 1
[01:28:34.105] SequentialFuture started (and completed)
[01:28:34.105] signalConditions() ...
[01:28:34.106]  - include = 'immediateCondition'
[01:28:34.106]  - exclude = 
[01:28:34.106]  - resignal = FALSE
[01:28:34.106]  - Number of conditions: 63
[01:28:34.106] signalConditions() ... done
[01:28:34.107] - Launch lazy future ... done
[01:28:34.107] run() for 'SequentialFuture' ... done
[01:28:34.107] signalConditions() ...
[01:28:34.107]  - include = 'immediateCondition'
[01:28:34.107]  - exclude = 
[01:28:34.107]  - resignal = FALSE
[01:28:34.108]  - Number of conditions: 63
[01:28:34.108] signalConditions() ... done
[01:28:34.108] Future state: 'finished'
[01:28:34.108] signalConditions() ...
[01:28:34.108]  - include = 'condition'
[01:28:34.109]  - exclude = 'immediateCondition'
[01:28:34.109]  - resignal = TRUE
[01:28:34.109]  - Number of conditions: 63
[01:28:34.109]  - Condition #1: 'simpleMessage', 'message', 'condition'
[01:28:34.031] getGlobalsAndPackages() ...
[01:28:34.109]  - Condition #2: 'simpleMessage', 'message', 'condition'
[01:28:34.031] Searching for globals...
[01:28:34.110]  - Condition #3: 'simpleMessage', 'message', 'condition'
[01:28:34.047] - globals found: [4] 'subset', 'data', '==', 'a'
[01:28:34.110]  - Condition #4: 'simpleMessage', 'message', 'condition'
[01:28:34.047] Searching for globals ... DONE
[01:28:34.110]  - Condition #5: 'simpleMessage', 'message', 'condition'
[01:28:34.048] Resolving globals: FALSE
[01:28:34.110]  - Condition #6: 'simpleMessage', 'message', 'condition'
[01:28:34.048] The total size of the 1 globals is 128 bytes (128 bytes)
[01:28:34.110]  - Condition #7: 'simpleMessage', 'message', 'condition'
[01:28:34.049] The total size of the 1 globals exported for future expression ('subset(data, a == 2)') is 128 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (128 bytes of class 'list')
[01:28:34.111]  - Condition #8: 'simpleMessage', 'message', 'condition'
[01:28:34.049] - globals: [1] 'data'
[01:28:34.111]  - Condition #9: 'simpleMessage', 'message', 'condition'
[01:28:34.049] 
[01:28:34.111]  - Condition #10: 'simpleMessage', 'message', 'condition'
[01:28:34.049] getGlobalsAndPackages() ... DONE
[01:28:34.111]  - Condition #11: 'simpleMessage', 'message', 'condition'
[01:28:34.050] run() for 'Future' ...
[01:28:34.112]  - Condition #12: 'simpleMessage', 'message', 'condition'
[01:28:34.050] - state: 'created'
[01:28:34.112]  - Condition #13: 'simpleMessage', 'message', 'condition'
[01:28:34.050] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:34.112]  - Condition #14: 'simpleMessage', 'message', 'condition'
[01:28:34.065] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:34.112]  - Condition #15: 'simpleMessage', 'message', 'condition'
[01:28:34.065] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:34.112]  - Condition #16: 'simpleMessage', 'message', 'condition'
[01:28:34.066]   - Field: 'node'
[01:28:34.113]  - Condition #17: 'simpleMessage', 'message', 'condition'
[01:28:34.066]   - Field: 'label'
[01:28:34.113]  - Condition #18: 'simpleMessage', 'message', 'condition'
[01:28:34.066]   - Field: 'local'
[01:28:34.113]  - Condition #19: 'simpleMessage', 'message', 'condition'
[01:28:34.066]   - Field: 'owner'
[01:28:34.113]  - Condition #20: 'simpleMessage', 'message', 'condition'
[01:28:34.067]   - Field: 'envir'
[01:28:34.114]  - Condition #21: 'simpleMessage', 'message', 'condition'
[01:28:34.067]   - Field: 'workers'
[01:28:34.114]  - Condition #22: 'simpleMessage', 'message', 'condition'
[01:28:34.067]   - Field: 'packages'
[01:28:34.114]  - Condition #23: 'simpleMessage', 'message', 'condition'
[01:28:34.067]   - Field: 'gc'
[01:28:34.114]  - Condition #24: 'simpleMessage', 'message', 'condition'
[01:28:34.067]   - Field: 'conditions'
[01:28:34.115]  - Condition #25: 'simpleMessage', 'message', 'condition'
[01:28:34.068]   - Field: 'persistent'
[01:28:34.115]  - Condition #26: 'simpleMessage', 'message', 'condition'
[01:28:34.068]   - Field: 'expr'
[01:28:34.115]  - Condition #27: 'simpleMessage', 'message', 'condition'
[01:28:34.068]   - Field: 'uuid'
[01:28:34.115]  - Condition #28: 'simpleMessage', 'message', 'condition'
[01:28:34.068]   - Field: 'seed'
[01:28:34.115]  - Condition #29: 'simpleMessage', 'message', 'condition'
[01:28:34.068]   - Field: 'version'
[01:28:34.116]  - Condition #30: 'simpleMessage', 'message', 'condition'
[01:28:34.068]   - Field: 'result'
[01:28:34.116]  - Condition #31: 'simpleMessage', 'message', 'condition'
[01:28:34.069]   - Field: 'asynchronous'
[01:28:34.116]  - Condition #32: 'simpleMessage', 'message', 'condition'
[01:28:34.069]   - Field: 'calls'
[01:28:34.116]  - Condition #33: 'simpleMessage', 'message', 'condition'
[01:28:34.069]   - Field: 'globals'
[01:28:34.117]  - Condition #34: 'simpleMessage', 'message', 'condition'
[01:28:34.069]   - Field: 'stdout'
[01:28:34.117]  - Condition #35: 'simpleMessage', 'message', 'condition'
[01:28:34.069]   - Field: 'earlySignal'
[01:28:34.117]  - Condition #36: 'simpleMessage', 'message', 'condition'
[01:28:34.070]   - Field: 'lazy'
[01:28:34.117]  - Condition #37: 'simpleMessage', 'message', 'condition'
[01:28:34.070]   - Field: 'state'
[01:28:34.117]  - Condition #38: 'simpleMessage', 'message', 'condition'
[01:28:34.070] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:34.118]  - Condition #39: 'simpleMessage', 'message', 'condition'
[01:28:34.070] - Launch lazy future ...
[01:28:34.118]  - Condition #40: 'simpleMessage', 'message', 'condition'
[01:28:34.071] Packages needed by the future expression (n = 0): <none>
[01:28:34.118]  - Condition #41: 'simpleMessage', 'message', 'condition'
[01:28:34.071] Packages needed by future strategies (n = 0): <none>
[01:28:34.118]  - Condition #42: 'simpleMessage', 'message', 'condition'
[01:28:34.071] {
[01:28:34.071]     {
[01:28:34.071]         {
[01:28:34.071]             ...future.startTime <- base::Sys.time()
[01:28:34.071]             {
[01:28:34.071]                 {
[01:28:34.071]                   {
[01:28:34.071]                     {
[01:28:34.071]                       base::local({
[01:28:34.071]                         has_future <- base::requireNamespace("future", 
[01:28:34.071]                           quietly = TRUE)
[01:28:34.071]                         if (has_future) {
[01:28:34.071]                           ns <- base::getNamespace("future")
[01:28:34.071]                           version <- ns[[".package"]][["version"]]
[01:28:34.071]                           if (is.null(version)) 
[01:28:34.071]                             version <- utils::packageVersion("future")
[01:28:34.071]                         }
[01:28:34.071]                         else {
[01:28:34.071]                           version <- NULL
[01:28:34.071]                         }
[01:28:34.071]                         if (!has_future || version < "1.8.0") {
[01:28:34.071]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:34.071]                             "", base::R.version$version.string), 
[01:28:34.071]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:34.071]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:34.071]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:34.071]                               "release", "version")], collapse = " "), 
[01:28:34.071]                             hostname = base::Sys.info()[["nodename"]])
[01:28:34.071]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:34.071]                             info)
[01:28:34.071]                           info <- base::paste(info, collapse = "; ")
[01:28:34.071]                           if (!has_future) {
[01:28:34.071]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:34.071]                               info)
[01:28:34.071]                           }
[01:28:34.071]                           else {
[01:28:34.071]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:34.071]                               info, version)
[01:28:34.071]                           }
[01:28:34.071]                           base::stop(msg)
[01:28:34.071]                         }
[01:28:34.071]                       })
[01:28:34.071]                     }
[01:28:34.071]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:34.071]                     base::options(mc.cores = 1L)
[01:28:34.071]                   }
[01:28:34.071]                   options(future.plan = NULL)
[01:28:34.071]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.071]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:34.071]                 }
[01:28:34.071]                 ...future.workdir <- getwd()
[01:28:34.071]             }
[01:28:34.071]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:34.071]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:34.071]         }
[01:28:34.071]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:34.071]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:34.071]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:34.071]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:34.071]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:34.071]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:34.071]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:34.071]             base::names(...future.oldOptions))
[01:28:34.071]     }
[01:28:34.071]     if (FALSE) {
[01:28:34.071]     }
[01:28:34.071]     else {
[01:28:34.071]         if (TRUE) {
[01:28:34.071]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:34.071]                 open = "w")
[01:28:34.071]         }
[01:28:34.071]         else {
[01:28:34.071]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:34.071]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:34.071]         }
[01:28:34.071]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:34.071]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:34.071]             base::sink(type = "output", split = FALSE)
[01:28:34.071]             base::close(...future.stdout)
[01:28:34.071]         }, add = TRUE)
[01:28:34.071]     }
[01:28:34.071]     ...future.frame <- base::sys.nframe()
[01:28:34.071]     ...future.conditions <- base::list()
[01:28:34.071]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:34.071]     if (FALSE) {
[01:28:34.071]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:34.071]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:34.071]     }
[01:28:34.071]     ...future.result <- base::tryCatch({
[01:28:34.071]         base::withCallingHandlers({
[01:28:34.071]             ...future.value <- base::withVisible(base::local({
[01:28:34.071]                 ...future.makeSendCondition <- base::local({
[01:28:34.071]                   sendCondition <- NULL
[01:28:34.071]                   function(frame = 1L) {
[01:28:34.071]                     if (is.function(sendCondition)) 
[01:28:34.071]                       return(sendCondition)
[01:28:34.071]                     ns <- getNamespace("parallel")
[01:28:34.071]                     if (exists("sendData", mode = "function", 
[01:28:34.071]                       envir = ns)) {
[01:28:34.071]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:34.071]                         envir = ns)
[01:28:34.071]                       envir <- sys.frame(frame)
[01:28:34.071]                       master <- NULL
[01:28:34.071]                       while (!identical(envir, .GlobalEnv) && 
[01:28:34.071]                         !identical(envir, emptyenv())) {
[01:28:34.071]                         if (exists("master", mode = "list", envir = envir, 
[01:28:34.071]                           inherits = FALSE)) {
[01:28:34.071]                           master <- get("master", mode = "list", 
[01:28:34.071]                             envir = envir, inherits = FALSE)
[01:28:34.071]                           if (inherits(master, c("SOCKnode", 
[01:28:34.071]                             "SOCK0node"))) {
[01:28:34.071]                             sendCondition <<- function(cond) {
[01:28:34.071]                               data <- list(type = "VALUE", value = cond, 
[01:28:34.071]                                 success = TRUE)
[01:28:34.071]                               parallel_sendData(master, data)
[01:28:34.071]                             }
[01:28:34.071]                             return(sendCondition)
[01:28:34.071]                           }
[01:28:34.071]                         }
[01:28:34.071]                         frame <- frame + 1L
[01:28:34.071]                         envir <- sys.frame(frame)
[01:28:34.071]                       }
[01:28:34.071]                     }
[01:28:34.071]                     sendCondition <<- function(cond) NULL
[01:28:34.071]                   }
[01:28:34.071]                 })
[01:28:34.071]                 withCallingHandlers({
[01:28:34.071]                   subset(data, a == 2)
[01:28:34.071]                 }, immediateCondition = function(cond) {
[01:28:34.071]                   sendCondition <- ...future.makeSendCondition()
[01:28:34.071]                   sendCondition(cond)
[01:28:34.071]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.071]                   {
[01:28:34.071]                     inherits <- base::inherits
[01:28:34.071]                     invokeRestart <- base::invokeRestart
[01:28:34.071]                     is.null <- base::is.null
[01:28:34.071]                     muffled <- FALSE
[01:28:34.071]                     if (inherits(cond, "message")) {
[01:28:34.071]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:34.071]                       if (muffled) 
[01:28:34.071]                         invokeRestart("muffleMessage")
[01:28:34.071]                     }
[01:28:34.071]                     else if (inherits(cond, "warning")) {
[01:28:34.071]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:34.071]                       if (muffled) 
[01:28:34.071]                         invokeRestart("muffleWarning")
[01:28:34.071]                     }
[01:28:34.071]                     else if (inherits(cond, "condition")) {
[01:28:34.071]                       if (!is.null(pattern)) {
[01:28:34.071]                         computeRestarts <- base::computeRestarts
[01:28:34.071]                         grepl <- base::grepl
[01:28:34.071]                         restarts <- computeRestarts(cond)
[01:28:34.071]                         for (restart in restarts) {
[01:28:34.071]                           name <- restart$name
[01:28:34.071]                           if (is.null(name)) 
[01:28:34.071]                             next
[01:28:34.071]                           if (!grepl(pattern, name)) 
[01:28:34.071]                             next
[01:28:34.071]                           invokeRestart(restart)
[01:28:34.071]                           muffled <- TRUE
[01:28:34.071]                           break
[01:28:34.071]                         }
[01:28:34.071]                       }
[01:28:34.071]                     }
[01:28:34.071]                     invisible(muffled)
[01:28:34.071]                   }
[01:28:34.071]                   muffleCondition(cond)
[01:28:34.071]                 })
[01:28:34.071]             }))
[01:28:34.071]             future::FutureResult(value = ...future.value$value, 
[01:28:34.071]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.071]                   ...future.rng), globalenv = if (FALSE) 
[01:28:34.071]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:34.071]                     ...future.globalenv.names))
[01:28:34.071]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:34.071]         }, condition = base::local({
[01:28:34.071]             c <- base::c
[01:28:34.071]             inherits <- base::inherits
[01:28:34.071]             invokeRestart <- base::invokeRestart
[01:28:34.071]             length <- base::length
[01:28:34.071]             list <- base::list
[01:28:34.071]             seq.int <- base::seq.int
[01:28:34.071]             signalCondition <- base::signalCondition
[01:28:34.071]             sys.calls <- base::sys.calls
[01:28:34.071]             `[[` <- base::`[[`
[01:28:34.071]             `+` <- base::`+`
[01:28:34.071]             `<<-` <- base::`<<-`
[01:28:34.071]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:34.071]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:34.071]                   3L)]
[01:28:34.071]             }
[01:28:34.071]             function(cond) {
[01:28:34.071]                 is_error <- inherits(cond, "error")
[01:28:34.071]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:34.071]                   NULL)
[01:28:34.071]                 if (is_error) {
[01:28:34.071]                   sessionInformation <- function() {
[01:28:34.071]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:34.071]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:34.071]                       search = base::search(), system = base::Sys.info())
[01:28:34.071]                   }
[01:28:34.071]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.071]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:34.071]                     cond$call), session = sessionInformation(), 
[01:28:34.071]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:34.071]                   signalCondition(cond)
[01:28:34.071]                 }
[01:28:34.071]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:34.071]                 "immediateCondition"))) {
[01:28:34.071]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:34.071]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.071]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:34.071]                   if (TRUE && !signal) {
[01:28:34.071]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.071]                     {
[01:28:34.071]                       inherits <- base::inherits
[01:28:34.071]                       invokeRestart <- base::invokeRestart
[01:28:34.071]                       is.null <- base::is.null
[01:28:34.071]                       muffled <- FALSE
[01:28:34.071]                       if (inherits(cond, "message")) {
[01:28:34.071]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.071]                         if (muffled) 
[01:28:34.071]                           invokeRestart("muffleMessage")
[01:28:34.071]                       }
[01:28:34.071]                       else if (inherits(cond, "warning")) {
[01:28:34.071]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.071]                         if (muffled) 
[01:28:34.071]                           invokeRestart("muffleWarning")
[01:28:34.071]                       }
[01:28:34.071]                       else if (inherits(cond, "condition")) {
[01:28:34.071]                         if (!is.null(pattern)) {
[01:28:34.071]                           computeRestarts <- base::computeRestarts
[01:28:34.071]                           grepl <- base::grepl
[01:28:34.071]                           restarts <- computeRestarts(cond)
[01:28:34.071]                           for (restart in restarts) {
[01:28:34.071]                             name <- restart$name
[01:28:34.071]                             if (is.null(name)) 
[01:28:34.071]                               next
[01:28:34.071]                             if (!grepl(pattern, name)) 
[01:28:34.071]                               next
[01:28:34.071]                             invokeRestart(restart)
[01:28:34.071]                             muffled <- TRUE
[01:28:34.071]                             break
[01:28:34.071]                           }
[01:28:34.071]                         }
[01:28:34.071]                       }
[01:28:34.071]                       invisible(muffled)
[01:28:34.071]                     }
[01:28:34.071]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.071]                   }
[01:28:34.071]                 }
[01:28:34.071]                 else {
[01:28:34.071]                   if (TRUE) {
[01:28:34.071]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.071]                     {
[01:28:34.071]                       inherits <- base::inherits
[01:28:34.071]                       invokeRestart <- base::invokeRestart
[01:28:34.071]                       is.null <- base::is.null
[01:28:34.071]                       muffled <- FALSE
[01:28:34.071]                       if (inherits(cond, "message")) {
[01:28:34.071]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.071]                         if (muffled) 
[01:28:34.071]                           invokeRestart("muffleMessage")
[01:28:34.071]                       }
[01:28:34.071]                       else if (inherits(cond, "warning")) {
[01:28:34.071]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.071]                         if (muffled) 
[01:28:34.071]                           invokeRestart("muffleWarning")
[01:28:34.071]                       }
[01:28:34.071]                       else if (inherits(cond, "condition")) {
[01:28:34.071]                         if (!is.null(pattern)) {
[01:28:34.071]                           computeRestarts <- base::computeRestarts
[01:28:34.071]                           grepl <- base::grepl
[01:28:34.071]                           restarts <- computeRestarts(cond)
[01:28:34.071]                           for (restart in restarts) {
[01:28:34.071]                             name <- restart$name
[01:28:34.071]                             if (is.null(name)) 
[01:28:34.071]                               next
[01:28:34.071]                             if (!grepl(pattern, name)) 
[01:28:34.071]                               next
[01:28:34.071]                             invokeRestart(restart)
[01:28:34.071]                             muffled <- TRUE
[01:28:34.071]                             break
[01:28:34.071]                           }
[01:28:34.071]                         }
[01:28:34.071]                       }
[01:28:34.071]                       invisible(muffled)
[01:28:34.071]                     }
[01:28:34.071]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.071]                   }
[01:28:34.071]                 }
[01:28:34.071]             }
[01:28:34.071]         }))
[01:28:34.071]     }, error = function(ex) {
[01:28:34.071]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:34.071]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.071]                 ...future.rng), started = ...future.startTime, 
[01:28:34.071]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:34.071]             version = "1.8"), class = "FutureResult")
[01:28:34.071]     }, finally = {
[01:28:34.071]         if (!identical(...future.workdir, getwd())) 
[01:28:34.071]             setwd(...future.workdir)
[01:28:34.071]         {
[01:28:34.071]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:34.071]                 ...future.oldOptions$nwarnings <- NULL
[01:28:34.071]             }
[01:28:34.071]             base::options(...future.oldOptions)
[01:28:34.071]             if (.Platform$OS.type == "windows") {
[01:28:34.071]                 old_names <- names(...future.oldEnvVars)
[01:28:34.071]                 envs <- base::Sys.getenv()
[01:28:34.071]                 names <- names(envs)
[01:28:34.071]                 common <- intersect(names, old_names)
[01:28:34.071]                 added <- setdiff(names, old_names)
[01:28:34.071]                 removed <- setdiff(old_names, names)
[01:28:34.071]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:34.071]                   envs[common]]
[01:28:34.071]                 NAMES <- toupper(changed)
[01:28:34.071]                 args <- list()
[01:28:34.071]                 for (kk in seq_along(NAMES)) {
[01:28:34.071]                   name <- changed[[kk]]
[01:28:34.071]                   NAME <- NAMES[[kk]]
[01:28:34.071]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.071]                     next
[01:28:34.071]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.071]                 }
[01:28:34.071]                 NAMES <- toupper(added)
[01:28:34.071]                 for (kk in seq_along(NAMES)) {
[01:28:34.071]                   name <- added[[kk]]
[01:28:34.071]                   NAME <- NAMES[[kk]]
[01:28:34.071]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.071]                     next
[01:28:34.071]                   args[[name]] <- ""
[01:28:34.071]                 }
[01:28:34.071]                 NAMES <- toupper(removed)
[01:28:34.071]                 for (kk in seq_along(NAMES)) {
[01:28:34.071]                   name <- removed[[kk]]
[01:28:34.071]                   NAME <- NAMES[[kk]]
[01:28:34.071]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.071]                     next
[01:28:34.071]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.071]                 }
[01:28:34.071]                 if (length(args) > 0) 
[01:28:34.071]                   base::do.call(base::Sys.setenv, args = args)
[01:28:34.071]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:34.071]             }
[01:28:34.071]             else {
[01:28:34.071]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:34.071]             }
[01:28:34.071]             {
[01:28:34.071]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:34.071]                   0L) {
[01:28:34.071]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:34.071]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:34.071]                   base::options(opts)
[01:28:34.071]                 }
[01:28:34.071]                 {
[01:28:34.071]                   {
[01:28:34.071]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:34.071]                     NULL
[01:28:34.071]                   }
[01:28:34.071]                   options(future.plan = NULL)
[01:28:34.071]                   if (is.na(NA_character_)) 
[01:28:34.071]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.071]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:34.071]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:34.071]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:34.071]                     envir = parent.frame()) 
[01:28:34.071]                   {
[01:28:34.071]                     if (is.function(workers)) 
[01:28:34.071]                       workers <- workers()
[01:28:34.071]                     workers <- structure(as.integer(workers), 
[01:28:34.071]                       class = class(workers))
[01:28:34.071]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:34.071]                       workers >= 1)
[01:28:34.071]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:34.071]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:34.071]                     }
[01:28:34.071]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:34.071]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:34.071]                       envir = envir)
[01:28:34.071]                     if (!future$lazy) 
[01:28:34.071]                       future <- run(future)
[01:28:34.071]                     invisible(future)
[01:28:34.071]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.071]                 }
[01:28:34.071]             }
[01:28:34.071]         }
[01:28:34.071]     })
[01:28:34.071]     if (TRUE) {
[01:28:34.071]         base::sink(type = "output", split = FALSE)
[01:28:34.071]         if (TRUE) {
[01:28:34.071]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:34.071]         }
[01:28:34.071]         else {
[01:28:34.071]             ...future.result["stdout"] <- base::list(NULL)
[01:28:34.071]         }
[01:28:34.071]         base::close(...future.stdout)
[01:28:34.071]         ...future.stdout <- NULL
[01:28:34.071]     }
[01:28:34.071]     ...future.result$conditions <- ...future.conditions
[01:28:34.071]     ...future.result$finished <- base::Sys.time()
[01:28:34.071]     ...future.result
[01:28:34.071] }
[01:28:34.119]  - Condition #43: 'simpleMessage', 'message', 'condition'
[01:28:34.077] Exporting 1 global objects (128 bytes) to cluster node #1 ...
[01:28:34.119]  - Condition #44: 'simpleMessage', 'message', 'condition'
[01:28:34.077] Exporting 'data' (128 bytes) to cluster node #1 ...
[01:28:34.119]  - Condition #45: 'simpleMessage', 'message', 'condition'
[01:28:34.078] Exporting 'data' (128 bytes) to cluster node #1 ... DONE
[01:28:34.119]  - Condition #46: 'simpleMessage', 'message', 'condition'
[01:28:34.078] Exporting 1 global objects (128 bytes) to cluster node #1 ... DONE
[01:28:34.120]  - Condition #47: 'simpleMessage', 'message', 'condition'
[01:28:34.079] MultisessionFuture started
[01:28:34.120]  - Condition #48: 'simpleMessage', 'message', 'condition'
[01:28:34.079] - Launch lazy future ... done
[01:28:34.120]  - Condition #49: 'simpleMessage', 'message', 'condition'
[01:28:34.079] run() for 'MultisessionFuture' ... done
[01:28:34.120]  - Condition #50: 'simpleMessage', 'message', 'condition'
[01:28:34.079] result() for ClusterFuture ...
[01:28:34.121]  - Condition #51: 'simpleMessage', 'message', 'condition'
[01:28:34.080] receiveMessageFromWorker() for ClusterFuture ...
[01:28:34.121]  - Condition #52: 'simpleMessage', 'message', 'condition'
[01:28:34.080] - Validating connection of MultisessionFuture
[01:28:34.121]  - Condition #53: 'simpleMessage', 'message', 'condition'
[01:28:34.101] - received message: FutureResult
[01:28:34.121]  - Condition #54: 'simpleMessage', 'message', 'condition'
[01:28:34.101] - Received FutureResult
[01:28:34.121]  - Condition #55: 'simpleMessage', 'message', 'condition'
[01:28:34.102] - Erased future from FutureRegistry
[01:28:34.122]  - Condition #56: 'simpleMessage', 'message', 'condition'
[01:28:34.102] result() for ClusterFuture ...
[01:28:34.123]  - Condition #57: 'simpleMessage', 'message', 'condition'
[01:28:34.102] - result already collected: FutureResult
[01:28:34.123]  - Condition #58: 'simpleMessage', 'message', 'condition'
[01:28:34.102] result() for ClusterFuture ... done
[01:28:34.123]  - Condition #59: 'simpleMessage', 'message', 'condition'
[01:28:34.102] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:34.124]  - Condition #60: 'simpleMessage', 'message', 'condition'
[01:28:34.102] result() for ClusterFuture ... done
[01:28:34.124]  - Condition #61: 'simpleMessage', 'message', 'condition'
[01:28:34.103] result() for ClusterFuture ...
[01:28:34.125]  - Condition #62: 'simpleMessage', 'message', 'condition'
[01:28:34.103] - result already collected: FutureResult
[01:28:34.125]  - Condition #63: 'simpleMessage', 'message', 'condition'
[01:28:34.103] result() for ClusterFuture ... done
[01:28:34.125] signalConditions() ... done
- plan(list('sequential', 'multisession')) ... DONE
- plan(list('multisession', 'sequential')) ...
[01:28:34.126] plan(): Setting new future strategy stack:
[01:28:34.126] List of future strategies:
[01:28:34.126] 1. multisession:
[01:28:34.126]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.126]    - tweaked: FALSE
[01:28:34.126]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.126] 2. sequential:
[01:28:34.126]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:34.126]    - tweaked: FALSE
[01:28:34.126]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.129] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:34.129] multisession:
[01:28:34.129] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.129] - tweaked: FALSE
[01:28:34.129] - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.134] getGlobalsAndPackages() ...
[01:28:34.134] Not searching for globals
[01:28:34.135] - globals: [0] <none>
[01:28:34.135] getGlobalsAndPackages() ... DONE
[01:28:34.136] [local output] makeClusterPSOCK() ...
[01:28:34.136] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:34.139] [local output] Base port: 29565
[01:28:34.140] [local output] Getting setup options for 2 cluster nodes ...
[01:28:34.140] [local output]  - Node 1 of 2 ...
[01:28:34.141] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:34.142] [local output] Rscript port: 29565

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

[01:28:34.145] [local output] Rscript port: 29565

[01:28:34.146] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:34.146] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:34.146] [local output] Setting up PSOCK nodes in parallel
[01:28:34.147] List of 36
[01:28:34.147]  $ worker          : chr "localhost"
[01:28:34.147]   ..- attr(*, "localhost")= logi TRUE
[01:28:34.147]  $ master          : chr "localhost"
[01:28:34.147]  $ port            : int 29565
[01:28:34.147]  $ connectTimeout  : num 120
[01:28:34.147]  $ timeout         : num 120
[01:28:34.147]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:34.147]  $ homogeneous     : logi TRUE
[01:28:34.147]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=nested_futures.R:8736:CRANWIN3:C"| __truncated__
[01:28:34.147]  $ rscript_envs    : NULL
[01:28:34.147]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:34.147]  $ rscript_startup : NULL
[01:28:34.147]  $ rscript_sh      : chr "cmd"
[01:28:34.147]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:34.147]  $ methods         : logi TRUE
[01:28:34.147]  $ socketOptions   : chr "no-delay"
[01:28:34.147]  $ useXDR          : logi FALSE
[01:28:34.147]  $ outfile         : chr "/dev/null"
[01:28:34.147]  $ renice          : int NA
[01:28:34.147]  $ rshcmd          : NULL
[01:28:34.147]  $ user            : chr(0) 
[01:28:34.147]  $ revtunnel       : logi FALSE
[01:28:34.147]  $ rshlogfile      : NULL
[01:28:34.147]  $ rshopts         : chr(0) 
[01:28:34.147]  $ rank            : int 1
[01:28:34.147]  $ manual          : logi FALSE
[01:28:34.147]  $ dryrun          : logi FALSE
[01:28:34.147]  $ quiet           : logi FALSE
[01:28:34.147]  $ setup_strategy  : chr "parallel"
[01:28:34.147]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:34.147]  $ pidfile         : chr "D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.22209c754f7.pid"
[01:28:34.147]  $ rshcmd_label    : NULL
[01:28:34.147]  $ rsh_call        : NULL
[01:28:34.147]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:34.147]  $ localMachine    : logi TRUE
[01:28:34.147]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:34.147]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:34.147]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:34.147]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:34.147]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:34.147]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:34.147]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:34.147]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:34.147]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:34.147]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:34.147]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:34.147]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:34.147]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:34.147]  $ arguments       :List of 28
[01:28:34.147]   ..$ worker          : chr "localhost"
[01:28:34.147]   ..$ master          : NULL
[01:28:34.147]   ..$ port            : int 29565
[01:28:34.147]   ..$ connectTimeout  : num 120
[01:28:34.147]   ..$ timeout         : num 120
[01:28:34.147]   ..$ rscript         : NULL
[01:28:34.147]   ..$ homogeneous     : NULL
[01:28:34.147]   ..$ rscript_args    : NULL
[01:28:34.147]   ..$ rscript_envs    : NULL
[01:28:34.147]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:34.147]   ..$ rscript_startup : NULL
[01:28:34.147]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:34.147]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:34.147]   ..$ methods         : logi TRUE
[01:28:34.147]   ..$ socketOptions   : chr "no-delay"
[01:28:34.147]   ..$ useXDR          : logi FALSE
[01:28:34.147]   ..$ outfile         : chr "/dev/null"
[01:28:34.147]   ..$ renice          : int NA
[01:28:34.147]   ..$ rshcmd          : NULL
[01:28:34.147]   ..$ user            : NULL
[01:28:34.147]   ..$ revtunnel       : logi NA
[01:28:34.147]   ..$ rshlogfile      : NULL
[01:28:34.147]   ..$ rshopts         : NULL
[01:28:34.147]   ..$ rank            : int 1
[01:28:34.147]   ..$ manual          : logi FALSE
[01:28:34.147]   ..$ dryrun          : logi FALSE
[01:28:34.147]   ..$ quiet           : logi FALSE
[01:28:34.147]   ..$ setup_strategy  : chr "parallel"
[01:28:34.147]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:34.177] [local output] System call to launch all workers:
[01:28:34.177] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=nested_futures.R:8736:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.22209c754f7.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=29565 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:34.177] [local output] Starting PSOCK main server
[01:28:34.184] [local output] Workers launched
[01:28:34.185] [local output] Waiting for workers to connect back
[01:28:34.185]  - [local output] 0 workers out of 2 ready
[01:28:34.414]  - [local output] 0 workers out of 2 ready
[01:28:34.415]  - [local output] 1 workers out of 2 ready
[01:28:34.415]  - [local output] 2 workers out of 2 ready
[01:28:34.415] [local output] Launching of workers completed
[01:28:34.416] [local output] Collecting session information from workers
[01:28:34.416] [local output]  - Worker #1 of 2
[01:28:34.417] [local output]  - Worker #2 of 2
[01:28:34.417] [local output] makeClusterPSOCK() ... done
[01:28:34.430] Packages needed by the future expression (n = 0): <none>
[01:28:34.430] Packages needed by future strategies (n = 1): 'future'
[01:28:34.431] {
[01:28:34.431]     {
[01:28:34.431]         {
[01:28:34.431]             ...future.startTime <- base::Sys.time()
[01:28:34.431]             {
[01:28:34.431]                 {
[01:28:34.431]                   {
[01:28:34.431]                     {
[01:28:34.431]                       {
[01:28:34.431]                         base::local({
[01:28:34.431]                           has_future <- base::requireNamespace("future", 
[01:28:34.431]                             quietly = TRUE)
[01:28:34.431]                           if (has_future) {
[01:28:34.431]                             ns <- base::getNamespace("future")
[01:28:34.431]                             version <- ns[[".package"]][["version"]]
[01:28:34.431]                             if (is.null(version)) 
[01:28:34.431]                               version <- utils::packageVersion("future")
[01:28:34.431]                           }
[01:28:34.431]                           else {
[01:28:34.431]                             version <- NULL
[01:28:34.431]                           }
[01:28:34.431]                           if (!has_future || version < "1.8.0") {
[01:28:34.431]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:34.431]                               "", base::R.version$version.string), 
[01:28:34.431]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:34.431]                                 base::R.version$platform, 8 * 
[01:28:34.431]                                   base::.Machine$sizeof.pointer), 
[01:28:34.431]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:34.431]                                 "release", "version")], collapse = " "), 
[01:28:34.431]                               hostname = base::Sys.info()[["nodename"]])
[01:28:34.431]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:34.431]                               info)
[01:28:34.431]                             info <- base::paste(info, collapse = "; ")
[01:28:34.431]                             if (!has_future) {
[01:28:34.431]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:34.431]                                 info)
[01:28:34.431]                             }
[01:28:34.431]                             else {
[01:28:34.431]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:34.431]                                 info, version)
[01:28:34.431]                             }
[01:28:34.431]                             base::stop(msg)
[01:28:34.431]                           }
[01:28:34.431]                         })
[01:28:34.431]                       }
[01:28:34.431]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:34.431]                       base::options(mc.cores = 1L)
[01:28:34.431]                     }
[01:28:34.431]                     base::local({
[01:28:34.431]                       for (pkg in "future") {
[01:28:34.431]                         base::loadNamespace(pkg)
[01:28:34.431]                         base::library(pkg, character.only = TRUE)
[01:28:34.431]                       }
[01:28:34.431]                     })
[01:28:34.431]                   }
[01:28:34.431]                   options(future.plan = NULL)
[01:28:34.431]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.431]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:34.431]                   {
[01:28:34.431]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.431]                     if (!future$lazy) 
[01:28:34.431]                       future <- run(future)
[01:28:34.431]                     invisible(future)
[01:28:34.431]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.431]                 }
[01:28:34.431]                 ...future.workdir <- getwd()
[01:28:34.431]             }
[01:28:34.431]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:34.431]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:34.431]         }
[01:28:34.431]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:34.431]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:34.431]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:34.431]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:34.431]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:34.431]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:34.431]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:34.431]             base::names(...future.oldOptions))
[01:28:34.431]     }
[01:28:34.431]     if (FALSE) {
[01:28:34.431]     }
[01:28:34.431]     else {
[01:28:34.431]         if (TRUE) {
[01:28:34.431]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:34.431]                 open = "w")
[01:28:34.431]         }
[01:28:34.431]         else {
[01:28:34.431]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:34.431]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:34.431]         }
[01:28:34.431]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:34.431]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:34.431]             base::sink(type = "output", split = FALSE)
[01:28:34.431]             base::close(...future.stdout)
[01:28:34.431]         }, add = TRUE)
[01:28:34.431]     }
[01:28:34.431]     ...future.frame <- base::sys.nframe()
[01:28:34.431]     ...future.conditions <- base::list()
[01:28:34.431]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:34.431]     if (FALSE) {
[01:28:34.431]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:34.431]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:34.431]     }
[01:28:34.431]     ...future.result <- base::tryCatch({
[01:28:34.431]         base::withCallingHandlers({
[01:28:34.431]             ...future.value <- base::withVisible(base::local({
[01:28:34.431]                 ...future.makeSendCondition <- base::local({
[01:28:34.431]                   sendCondition <- NULL
[01:28:34.431]                   function(frame = 1L) {
[01:28:34.431]                     if (is.function(sendCondition)) 
[01:28:34.431]                       return(sendCondition)
[01:28:34.431]                     ns <- getNamespace("parallel")
[01:28:34.431]                     if (exists("sendData", mode = "function", 
[01:28:34.431]                       envir = ns)) {
[01:28:34.431]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:34.431]                         envir = ns)
[01:28:34.431]                       envir <- sys.frame(frame)
[01:28:34.431]                       master <- NULL
[01:28:34.431]                       while (!identical(envir, .GlobalEnv) && 
[01:28:34.431]                         !identical(envir, emptyenv())) {
[01:28:34.431]                         if (exists("master", mode = "list", envir = envir, 
[01:28:34.431]                           inherits = FALSE)) {
[01:28:34.431]                           master <- get("master", mode = "list", 
[01:28:34.431]                             envir = envir, inherits = FALSE)
[01:28:34.431]                           if (inherits(master, c("SOCKnode", 
[01:28:34.431]                             "SOCK0node"))) {
[01:28:34.431]                             sendCondition <<- function(cond) {
[01:28:34.431]                               data <- list(type = "VALUE", value = cond, 
[01:28:34.431]                                 success = TRUE)
[01:28:34.431]                               parallel_sendData(master, data)
[01:28:34.431]                             }
[01:28:34.431]                             return(sendCondition)
[01:28:34.431]                           }
[01:28:34.431]                         }
[01:28:34.431]                         frame <- frame + 1L
[01:28:34.431]                         envir <- sys.frame(frame)
[01:28:34.431]                       }
[01:28:34.431]                     }
[01:28:34.431]                     sendCondition <<- function(cond) NULL
[01:28:34.431]                   }
[01:28:34.431]                 })
[01:28:34.431]                 withCallingHandlers({
[01:28:34.431]                   NA
[01:28:34.431]                 }, immediateCondition = function(cond) {
[01:28:34.431]                   sendCondition <- ...future.makeSendCondition()
[01:28:34.431]                   sendCondition(cond)
[01:28:34.431]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.431]                   {
[01:28:34.431]                     inherits <- base::inherits
[01:28:34.431]                     invokeRestart <- base::invokeRestart
[01:28:34.431]                     is.null <- base::is.null
[01:28:34.431]                     muffled <- FALSE
[01:28:34.431]                     if (inherits(cond, "message")) {
[01:28:34.431]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:34.431]                       if (muffled) 
[01:28:34.431]                         invokeRestart("muffleMessage")
[01:28:34.431]                     }
[01:28:34.431]                     else if (inherits(cond, "warning")) {
[01:28:34.431]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:34.431]                       if (muffled) 
[01:28:34.431]                         invokeRestart("muffleWarning")
[01:28:34.431]                     }
[01:28:34.431]                     else if (inherits(cond, "condition")) {
[01:28:34.431]                       if (!is.null(pattern)) {
[01:28:34.431]                         computeRestarts <- base::computeRestarts
[01:28:34.431]                         grepl <- base::grepl
[01:28:34.431]                         restarts <- computeRestarts(cond)
[01:28:34.431]                         for (restart in restarts) {
[01:28:34.431]                           name <- restart$name
[01:28:34.431]                           if (is.null(name)) 
[01:28:34.431]                             next
[01:28:34.431]                           if (!grepl(pattern, name)) 
[01:28:34.431]                             next
[01:28:34.431]                           invokeRestart(restart)
[01:28:34.431]                           muffled <- TRUE
[01:28:34.431]                           break
[01:28:34.431]                         }
[01:28:34.431]                       }
[01:28:34.431]                     }
[01:28:34.431]                     invisible(muffled)
[01:28:34.431]                   }
[01:28:34.431]                   muffleCondition(cond)
[01:28:34.431]                 })
[01:28:34.431]             }))
[01:28:34.431]             future::FutureResult(value = ...future.value$value, 
[01:28:34.431]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.431]                   ...future.rng), globalenv = if (FALSE) 
[01:28:34.431]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:34.431]                     ...future.globalenv.names))
[01:28:34.431]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:34.431]         }, condition = base::local({
[01:28:34.431]             c <- base::c
[01:28:34.431]             inherits <- base::inherits
[01:28:34.431]             invokeRestart <- base::invokeRestart
[01:28:34.431]             length <- base::length
[01:28:34.431]             list <- base::list
[01:28:34.431]             seq.int <- base::seq.int
[01:28:34.431]             signalCondition <- base::signalCondition
[01:28:34.431]             sys.calls <- base::sys.calls
[01:28:34.431]             `[[` <- base::`[[`
[01:28:34.431]             `+` <- base::`+`
[01:28:34.431]             `<<-` <- base::`<<-`
[01:28:34.431]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:34.431]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:34.431]                   3L)]
[01:28:34.431]             }
[01:28:34.431]             function(cond) {
[01:28:34.431]                 is_error <- inherits(cond, "error")
[01:28:34.431]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:34.431]                   NULL)
[01:28:34.431]                 if (is_error) {
[01:28:34.431]                   sessionInformation <- function() {
[01:28:34.431]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:34.431]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:34.431]                       search = base::search(), system = base::Sys.info())
[01:28:34.431]                   }
[01:28:34.431]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.431]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:34.431]                     cond$call), session = sessionInformation(), 
[01:28:34.431]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:34.431]                   signalCondition(cond)
[01:28:34.431]                 }
[01:28:34.431]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:34.431]                 "immediateCondition"))) {
[01:28:34.431]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:34.431]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.431]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:34.431]                   if (TRUE && !signal) {
[01:28:34.431]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.431]                     {
[01:28:34.431]                       inherits <- base::inherits
[01:28:34.431]                       invokeRestart <- base::invokeRestart
[01:28:34.431]                       is.null <- base::is.null
[01:28:34.431]                       muffled <- FALSE
[01:28:34.431]                       if (inherits(cond, "message")) {
[01:28:34.431]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.431]                         if (muffled) 
[01:28:34.431]                           invokeRestart("muffleMessage")
[01:28:34.431]                       }
[01:28:34.431]                       else if (inherits(cond, "warning")) {
[01:28:34.431]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.431]                         if (muffled) 
[01:28:34.431]                           invokeRestart("muffleWarning")
[01:28:34.431]                       }
[01:28:34.431]                       else if (inherits(cond, "condition")) {
[01:28:34.431]                         if (!is.null(pattern)) {
[01:28:34.431]                           computeRestarts <- base::computeRestarts
[01:28:34.431]                           grepl <- base::grepl
[01:28:34.431]                           restarts <- computeRestarts(cond)
[01:28:34.431]                           for (restart in restarts) {
[01:28:34.431]                             name <- restart$name
[01:28:34.431]                             if (is.null(name)) 
[01:28:34.431]                               next
[01:28:34.431]                             if (!grepl(pattern, name)) 
[01:28:34.431]                               next
[01:28:34.431]                             invokeRestart(restart)
[01:28:34.431]                             muffled <- TRUE
[01:28:34.431]                             break
[01:28:34.431]                           }
[01:28:34.431]                         }
[01:28:34.431]                       }
[01:28:34.431]                       invisible(muffled)
[01:28:34.431]                     }
[01:28:34.431]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.431]                   }
[01:28:34.431]                 }
[01:28:34.431]                 else {
[01:28:34.431]                   if (TRUE) {
[01:28:34.431]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.431]                     {
[01:28:34.431]                       inherits <- base::inherits
[01:28:34.431]                       invokeRestart <- base::invokeRestart
[01:28:34.431]                       is.null <- base::is.null
[01:28:34.431]                       muffled <- FALSE
[01:28:34.431]                       if (inherits(cond, "message")) {
[01:28:34.431]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.431]                         if (muffled) 
[01:28:34.431]                           invokeRestart("muffleMessage")
[01:28:34.431]                       }
[01:28:34.431]                       else if (inherits(cond, "warning")) {
[01:28:34.431]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.431]                         if (muffled) 
[01:28:34.431]                           invokeRestart("muffleWarning")
[01:28:34.431]                       }
[01:28:34.431]                       else if (inherits(cond, "condition")) {
[01:28:34.431]                         if (!is.null(pattern)) {
[01:28:34.431]                           computeRestarts <- base::computeRestarts
[01:28:34.431]                           grepl <- base::grepl
[01:28:34.431]                           restarts <- computeRestarts(cond)
[01:28:34.431]                           for (restart in restarts) {
[01:28:34.431]                             name <- restart$name
[01:28:34.431]                             if (is.null(name)) 
[01:28:34.431]                               next
[01:28:34.431]                             if (!grepl(pattern, name)) 
[01:28:34.431]                               next
[01:28:34.431]                             invokeRestart(restart)
[01:28:34.431]                             muffled <- TRUE
[01:28:34.431]                             break
[01:28:34.431]                           }
[01:28:34.431]                         }
[01:28:34.431]                       }
[01:28:34.431]                       invisible(muffled)
[01:28:34.431]                     }
[01:28:34.431]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.431]                   }
[01:28:34.431]                 }
[01:28:34.431]             }
[01:28:34.431]         }))
[01:28:34.431]     }, error = function(ex) {
[01:28:34.431]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:34.431]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.431]                 ...future.rng), started = ...future.startTime, 
[01:28:34.431]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:34.431]             version = "1.8"), class = "FutureResult")
[01:28:34.431]     }, finally = {
[01:28:34.431]         if (!identical(...future.workdir, getwd())) 
[01:28:34.431]             setwd(...future.workdir)
[01:28:34.431]         {
[01:28:34.431]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:34.431]                 ...future.oldOptions$nwarnings <- NULL
[01:28:34.431]             }
[01:28:34.431]             base::options(...future.oldOptions)
[01:28:34.431]             if (.Platform$OS.type == "windows") {
[01:28:34.431]                 old_names <- names(...future.oldEnvVars)
[01:28:34.431]                 envs <- base::Sys.getenv()
[01:28:34.431]                 names <- names(envs)
[01:28:34.431]                 common <- intersect(names, old_names)
[01:28:34.431]                 added <- setdiff(names, old_names)
[01:28:34.431]                 removed <- setdiff(old_names, names)
[01:28:34.431]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:34.431]                   envs[common]]
[01:28:34.431]                 NAMES <- toupper(changed)
[01:28:34.431]                 args <- list()
[01:28:34.431]                 for (kk in seq_along(NAMES)) {
[01:28:34.431]                   name <- changed[[kk]]
[01:28:34.431]                   NAME <- NAMES[[kk]]
[01:28:34.431]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.431]                     next
[01:28:34.431]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.431]                 }
[01:28:34.431]                 NAMES <- toupper(added)
[01:28:34.431]                 for (kk in seq_along(NAMES)) {
[01:28:34.431]                   name <- added[[kk]]
[01:28:34.431]                   NAME <- NAMES[[kk]]
[01:28:34.431]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.431]                     next
[01:28:34.431]                   args[[name]] <- ""
[01:28:34.431]                 }
[01:28:34.431]                 NAMES <- toupper(removed)
[01:28:34.431]                 for (kk in seq_along(NAMES)) {
[01:28:34.431]                   name <- removed[[kk]]
[01:28:34.431]                   NAME <- NAMES[[kk]]
[01:28:34.431]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.431]                     next
[01:28:34.431]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.431]                 }
[01:28:34.431]                 if (length(args) > 0) 
[01:28:34.431]                   base::do.call(base::Sys.setenv, args = args)
[01:28:34.431]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:34.431]             }
[01:28:34.431]             else {
[01:28:34.431]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:34.431]             }
[01:28:34.431]             {
[01:28:34.431]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:34.431]                   0L) {
[01:28:34.431]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:34.431]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:34.431]                   base::options(opts)
[01:28:34.431]                 }
[01:28:34.431]                 {
[01:28:34.431]                   {
[01:28:34.431]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:34.431]                     NULL
[01:28:34.431]                   }
[01:28:34.431]                   options(future.plan = NULL)
[01:28:34.431]                   if (is.na(NA_character_)) 
[01:28:34.431]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.431]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:34.431]                   future::plan(list(a = function (..., workers = availableCores(), 
[01:28:34.431]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:34.431]                     envir = parent.frame()) 
[01:28:34.431]                   {
[01:28:34.431]                     if (is.function(workers)) 
[01:28:34.431]                       workers <- workers()
[01:28:34.431]                     workers <- structure(as.integer(workers), 
[01:28:34.431]                       class = class(workers))
[01:28:34.431]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:34.431]                       workers >= 1)
[01:28:34.431]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:34.431]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:34.431]                     }
[01:28:34.431]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:34.431]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:34.431]                       envir = envir)
[01:28:34.431]                     if (!future$lazy) 
[01:28:34.431]                       future <- run(future)
[01:28:34.431]                     invisible(future)
[01:28:34.431]                   }, b = function (..., envir = parent.frame()) 
[01:28:34.431]                   {
[01:28:34.431]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.431]                     if (!future$lazy) 
[01:28:34.431]                       future <- run(future)
[01:28:34.431]                     invisible(future)
[01:28:34.431]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.431]                 }
[01:28:34.431]             }
[01:28:34.431]         }
[01:28:34.431]     })
[01:28:34.431]     if (TRUE) {
[01:28:34.431]         base::sink(type = "output", split = FALSE)
[01:28:34.431]         if (TRUE) {
[01:28:34.431]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:34.431]         }
[01:28:34.431]         else {
[01:28:34.431]             ...future.result["stdout"] <- base::list(NULL)
[01:28:34.431]         }
[01:28:34.431]         base::close(...future.stdout)
[01:28:34.431]         ...future.stdout <- NULL
[01:28:34.431]     }
[01:28:34.431]     ...future.result$conditions <- ...future.conditions
[01:28:34.431]     ...future.result$finished <- base::Sys.time()
[01:28:34.431]     ...future.result
[01:28:34.431] }
[01:28:34.521] MultisessionFuture started
[01:28:34.522] result() for ClusterFuture ...
[01:28:34.522] receiveMessageFromWorker() for ClusterFuture ...
[01:28:34.522] - Validating connection of MultisessionFuture
[01:28:34.612] - received message: FutureResult
[01:28:34.613] - Received FutureResult
[01:28:34.613] - Erased future from FutureRegistry
[01:28:34.613] result() for ClusterFuture ...
[01:28:34.613] - result already collected: FutureResult
[01:28:34.613] result() for ClusterFuture ... done
[01:28:34.614] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:34.614] result() for ClusterFuture ... done
[01:28:34.614] result() for ClusterFuture ...
[01:28:34.614] - result already collected: FutureResult
[01:28:34.614] result() for ClusterFuture ... done
[01:28:34.614] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:34.617] plan(): nbrOfWorkers() = 2
[01:28:34.617] getGlobalsAndPackages() ...
[01:28:34.618] Searching for globals...
[01:28:34.645] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[01:28:34.645] Searching for globals ... DONE
[01:28:34.645] Resolving globals: FALSE
[01:28:34.647] The total size of the 2 globals is 55.46 KiB (56792 bytes)
[01:28:34.648] 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 55.46 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (55.34 KiB of class 'list') and 'strategy2' (120 bytes of class 'character')
[01:28:34.648] - globals: [2] 'nested', 'strategy2'
[01:28:34.648] - packages: [1] 'future'
[01:28:34.649] getGlobalsAndPackages() ... DONE
[01:28:34.649] run() for 'Future' ...
[01:28:34.649] - state: 'created'
[01:28:34.650] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:34.665] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:34.666] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:34.666]   - Field: 'node'
[01:28:34.666]   - Field: 'label'
[01:28:34.666]   - Field: 'local'
[01:28:34.666]   - Field: 'owner'
[01:28:34.667]   - Field: 'envir'
[01:28:34.667]   - Field: 'workers'
[01:28:34.667]   - Field: 'packages'
[01:28:34.667]   - Field: 'gc'
[01:28:34.667]   - Field: 'conditions'
[01:28:34.668]   - Field: 'persistent'
[01:28:34.668]   - Field: 'expr'
[01:28:34.668]   - Field: 'uuid'
[01:28:34.668]   - Field: 'seed'
[01:28:34.668]   - Field: 'version'
[01:28:34.669]   - Field: 'result'
[01:28:34.669]   - Field: 'asynchronous'
[01:28:34.669]   - Field: 'calls'
[01:28:34.669]   - Field: 'globals'
[01:28:34.669]   - Field: 'stdout'
[01:28:34.670]   - Field: 'earlySignal'
[01:28:34.670]   - Field: 'lazy'
[01:28:34.670]   - Field: 'state'
[01:28:34.670] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:34.670] - Launch lazy future ...
[01:28:34.671] Packages needed by the future expression (n = 1): 'future'
[01:28:34.671] Packages needed by future strategies (n = 1): 'future'
[01:28:34.672] {
[01:28:34.672]     {
[01:28:34.672]         {
[01:28:34.672]             ...future.startTime <- base::Sys.time()
[01:28:34.672]             {
[01:28:34.672]                 {
[01:28:34.672]                   {
[01:28:34.672]                     {
[01:28:34.672]                       {
[01:28:34.672]                         base::local({
[01:28:34.672]                           has_future <- base::requireNamespace("future", 
[01:28:34.672]                             quietly = TRUE)
[01:28:34.672]                           if (has_future) {
[01:28:34.672]                             ns <- base::getNamespace("future")
[01:28:34.672]                             version <- ns[[".package"]][["version"]]
[01:28:34.672]                             if (is.null(version)) 
[01:28:34.672]                               version <- utils::packageVersion("future")
[01:28:34.672]                           }
[01:28:34.672]                           else {
[01:28:34.672]                             version <- NULL
[01:28:34.672]                           }
[01:28:34.672]                           if (!has_future || version < "1.8.0") {
[01:28:34.672]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:34.672]                               "", base::R.version$version.string), 
[01:28:34.672]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:34.672]                                 base::R.version$platform, 8 * 
[01:28:34.672]                                   base::.Machine$sizeof.pointer), 
[01:28:34.672]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:34.672]                                 "release", "version")], collapse = " "), 
[01:28:34.672]                               hostname = base::Sys.info()[["nodename"]])
[01:28:34.672]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:34.672]                               info)
[01:28:34.672]                             info <- base::paste(info, collapse = "; ")
[01:28:34.672]                             if (!has_future) {
[01:28:34.672]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:34.672]                                 info)
[01:28:34.672]                             }
[01:28:34.672]                             else {
[01:28:34.672]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:34.672]                                 info, version)
[01:28:34.672]                             }
[01:28:34.672]                             base::stop(msg)
[01:28:34.672]                           }
[01:28:34.672]                         })
[01:28:34.672]                       }
[01:28:34.672]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:34.672]                       base::options(mc.cores = 1L)
[01:28:34.672]                     }
[01:28:34.672]                     base::local({
[01:28:34.672]                       for (pkg in "future") {
[01:28:34.672]                         base::loadNamespace(pkg)
[01:28:34.672]                         base::library(pkg, character.only = TRUE)
[01:28:34.672]                       }
[01:28:34.672]                     })
[01:28:34.672]                   }
[01:28:34.672]                   options(future.plan = NULL)
[01:28:34.672]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.672]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:34.672]                   {
[01:28:34.672]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.672]                     if (!future$lazy) 
[01:28:34.672]                       future <- run(future)
[01:28:34.672]                     invisible(future)
[01:28:34.672]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.672]                 }
[01:28:34.672]                 ...future.workdir <- getwd()
[01:28:34.672]             }
[01:28:34.672]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:34.672]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:34.672]         }
[01:28:34.672]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:34.672]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:34.672]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:34.672]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:34.672]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:34.672]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:34.672]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:34.672]             base::names(...future.oldOptions))
[01:28:34.672]     }
[01:28:34.672]     if (FALSE) {
[01:28:34.672]     }
[01:28:34.672]     else {
[01:28:34.672]         if (TRUE) {
[01:28:34.672]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:34.672]                 open = "w")
[01:28:34.672]         }
[01:28:34.672]         else {
[01:28:34.672]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:34.672]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:34.672]         }
[01:28:34.672]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:34.672]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:34.672]             base::sink(type = "output", split = FALSE)
[01:28:34.672]             base::close(...future.stdout)
[01:28:34.672]         }, add = TRUE)
[01:28:34.672]     }
[01:28:34.672]     ...future.frame <- base::sys.nframe()
[01:28:34.672]     ...future.conditions <- base::list()
[01:28:34.672]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:34.672]     if (FALSE) {
[01:28:34.672]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:34.672]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:34.672]     }
[01:28:34.672]     ...future.result <- base::tryCatch({
[01:28:34.672]         base::withCallingHandlers({
[01:28:34.672]             ...future.value <- base::withVisible(base::local({
[01:28:34.672]                 ...future.makeSendCondition <- base::local({
[01:28:34.672]                   sendCondition <- NULL
[01:28:34.672]                   function(frame = 1L) {
[01:28:34.672]                     if (is.function(sendCondition)) 
[01:28:34.672]                       return(sendCondition)
[01:28:34.672]                     ns <- getNamespace("parallel")
[01:28:34.672]                     if (exists("sendData", mode = "function", 
[01:28:34.672]                       envir = ns)) {
[01:28:34.672]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:34.672]                         envir = ns)
[01:28:34.672]                       envir <- sys.frame(frame)
[01:28:34.672]                       master <- NULL
[01:28:34.672]                       while (!identical(envir, .GlobalEnv) && 
[01:28:34.672]                         !identical(envir, emptyenv())) {
[01:28:34.672]                         if (exists("master", mode = "list", envir = envir, 
[01:28:34.672]                           inherits = FALSE)) {
[01:28:34.672]                           master <- get("master", mode = "list", 
[01:28:34.672]                             envir = envir, inherits = FALSE)
[01:28:34.672]                           if (inherits(master, c("SOCKnode", 
[01:28:34.672]                             "SOCK0node"))) {
[01:28:34.672]                             sendCondition <<- function(cond) {
[01:28:34.672]                               data <- list(type = "VALUE", value = cond, 
[01:28:34.672]                                 success = TRUE)
[01:28:34.672]                               parallel_sendData(master, data)
[01:28:34.672]                             }
[01:28:34.672]                             return(sendCondition)
[01:28:34.672]                           }
[01:28:34.672]                         }
[01:28:34.672]                         frame <- frame + 1L
[01:28:34.672]                         envir <- sys.frame(frame)
[01:28:34.672]                       }
[01:28:34.672]                     }
[01:28:34.672]                     sendCondition <<- function(cond) NULL
[01:28:34.672]                   }
[01:28:34.672]                 })
[01:28:34.672]                 withCallingHandlers({
[01:28:34.672]                   {
[01:28:34.672]                     a <- 1L
[01:28:34.672]                     plan_a <- unclass(future::plan("list"))
[01:28:34.672]                     nested_a <- nested[-1]
[01:28:34.672]                     stopifnot(length(nested_a) == 1L, length(plan_a) == 
[01:28:34.672]                       1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[01:28:34.672]                       strategy2))
[01:28:34.672]                     for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[01:28:34.672]                       "init") <- NULL
[01:28:34.672]                     for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[01:28:34.672]                       "init") <- NULL
[01:28:34.672]                     stopifnot(all.equal(plan_a, nested_a))
[01:28:34.672]                     y %<-% {
[01:28:34.672]                       b <- 2L
[01:28:34.672]                       plan_b <- future::plan("list")
[01:28:34.672]                       nested_b <- nested_a[-1]
[01:28:34.672]                       stopifnot(length(nested_b) == 0L, length(plan_b) == 
[01:28:34.672]                         1L, inherits(plan_b[[1]], "future"), 
[01:28:34.672]                         inherits(future::plan("next"), "sequential"))
[01:28:34.672]                       list(a = a, nested_a = nested_a, plan_a = plan_a, 
[01:28:34.672]                         b = b, nested_b = nested_b, plan_b = plan_b)
[01:28:34.672]                     }
[01:28:34.672]                     y
[01:28:34.672]                   }
[01:28:34.672]                 }, immediateCondition = function(cond) {
[01:28:34.672]                   sendCondition <- ...future.makeSendCondition()
[01:28:34.672]                   sendCondition(cond)
[01:28:34.672]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.672]                   {
[01:28:34.672]                     inherits <- base::inherits
[01:28:34.672]                     invokeRestart <- base::invokeRestart
[01:28:34.672]                     is.null <- base::is.null
[01:28:34.672]                     muffled <- FALSE
[01:28:34.672]                     if (inherits(cond, "message")) {
[01:28:34.672]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:34.672]                       if (muffled) 
[01:28:34.672]                         invokeRestart("muffleMessage")
[01:28:34.672]                     }
[01:28:34.672]                     else if (inherits(cond, "warning")) {
[01:28:34.672]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:34.672]                       if (muffled) 
[01:28:34.672]                         invokeRestart("muffleWarning")
[01:28:34.672]                     }
[01:28:34.672]                     else if (inherits(cond, "condition")) {
[01:28:34.672]                       if (!is.null(pattern)) {
[01:28:34.672]                         computeRestarts <- base::computeRestarts
[01:28:34.672]                         grepl <- base::grepl
[01:28:34.672]                         restarts <- computeRestarts(cond)
[01:28:34.672]                         for (restart in restarts) {
[01:28:34.672]                           name <- restart$name
[01:28:34.672]                           if (is.null(name)) 
[01:28:34.672]                             next
[01:28:34.672]                           if (!grepl(pattern, name)) 
[01:28:34.672]                             next
[01:28:34.672]                           invokeRestart(restart)
[01:28:34.672]                           muffled <- TRUE
[01:28:34.672]                           break
[01:28:34.672]                         }
[01:28:34.672]                       }
[01:28:34.672]                     }
[01:28:34.672]                     invisible(muffled)
[01:28:34.672]                   }
[01:28:34.672]                   muffleCondition(cond)
[01:28:34.672]                 })
[01:28:34.672]             }))
[01:28:34.672]             future::FutureResult(value = ...future.value$value, 
[01:28:34.672]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.672]                   ...future.rng), globalenv = if (FALSE) 
[01:28:34.672]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:34.672]                     ...future.globalenv.names))
[01:28:34.672]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:34.672]         }, condition = base::local({
[01:28:34.672]             c <- base::c
[01:28:34.672]             inherits <- base::inherits
[01:28:34.672]             invokeRestart <- base::invokeRestart
[01:28:34.672]             length <- base::length
[01:28:34.672]             list <- base::list
[01:28:34.672]             seq.int <- base::seq.int
[01:28:34.672]             signalCondition <- base::signalCondition
[01:28:34.672]             sys.calls <- base::sys.calls
[01:28:34.672]             `[[` <- base::`[[`
[01:28:34.672]             `+` <- base::`+`
[01:28:34.672]             `<<-` <- base::`<<-`
[01:28:34.672]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:34.672]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:34.672]                   3L)]
[01:28:34.672]             }
[01:28:34.672]             function(cond) {
[01:28:34.672]                 is_error <- inherits(cond, "error")
[01:28:34.672]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:34.672]                   NULL)
[01:28:34.672]                 if (is_error) {
[01:28:34.672]                   sessionInformation <- function() {
[01:28:34.672]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:34.672]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:34.672]                       search = base::search(), system = base::Sys.info())
[01:28:34.672]                   }
[01:28:34.672]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.672]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:34.672]                     cond$call), session = sessionInformation(), 
[01:28:34.672]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:34.672]                   signalCondition(cond)
[01:28:34.672]                 }
[01:28:34.672]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:34.672]                 "immediateCondition"))) {
[01:28:34.672]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:34.672]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.672]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:34.672]                   if (TRUE && !signal) {
[01:28:34.672]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.672]                     {
[01:28:34.672]                       inherits <- base::inherits
[01:28:34.672]                       invokeRestart <- base::invokeRestart
[01:28:34.672]                       is.null <- base::is.null
[01:28:34.672]                       muffled <- FALSE
[01:28:34.672]                       if (inherits(cond, "message")) {
[01:28:34.672]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.672]                         if (muffled) 
[01:28:34.672]                           invokeRestart("muffleMessage")
[01:28:34.672]                       }
[01:28:34.672]                       else if (inherits(cond, "warning")) {
[01:28:34.672]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.672]                         if (muffled) 
[01:28:34.672]                           invokeRestart("muffleWarning")
[01:28:34.672]                       }
[01:28:34.672]                       else if (inherits(cond, "condition")) {
[01:28:34.672]                         if (!is.null(pattern)) {
[01:28:34.672]                           computeRestarts <- base::computeRestarts
[01:28:34.672]                           grepl <- base::grepl
[01:28:34.672]                           restarts <- computeRestarts(cond)
[01:28:34.672]                           for (restart in restarts) {
[01:28:34.672]                             name <- restart$name
[01:28:34.672]                             if (is.null(name)) 
[01:28:34.672]                               next
[01:28:34.672]                             if (!grepl(pattern, name)) 
[01:28:34.672]                               next
[01:28:34.672]                             invokeRestart(restart)
[01:28:34.672]                             muffled <- TRUE
[01:28:34.672]                             break
[01:28:34.672]                           }
[01:28:34.672]                         }
[01:28:34.672]                       }
[01:28:34.672]                       invisible(muffled)
[01:28:34.672]                     }
[01:28:34.672]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.672]                   }
[01:28:34.672]                 }
[01:28:34.672]                 else {
[01:28:34.672]                   if (TRUE) {
[01:28:34.672]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.672]                     {
[01:28:34.672]                       inherits <- base::inherits
[01:28:34.672]                       invokeRestart <- base::invokeRestart
[01:28:34.672]                       is.null <- base::is.null
[01:28:34.672]                       muffled <- FALSE
[01:28:34.672]                       if (inherits(cond, "message")) {
[01:28:34.672]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.672]                         if (muffled) 
[01:28:34.672]                           invokeRestart("muffleMessage")
[01:28:34.672]                       }
[01:28:34.672]                       else if (inherits(cond, "warning")) {
[01:28:34.672]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.672]                         if (muffled) 
[01:28:34.672]                           invokeRestart("muffleWarning")
[01:28:34.672]                       }
[01:28:34.672]                       else if (inherits(cond, "condition")) {
[01:28:34.672]                         if (!is.null(pattern)) {
[01:28:34.672]                           computeRestarts <- base::computeRestarts
[01:28:34.672]                           grepl <- base::grepl
[01:28:34.672]                           restarts <- computeRestarts(cond)
[01:28:34.672]                           for (restart in restarts) {
[01:28:34.672]                             name <- restart$name
[01:28:34.672]                             if (is.null(name)) 
[01:28:34.672]                               next
[01:28:34.672]                             if (!grepl(pattern, name)) 
[01:28:34.672]                               next
[01:28:34.672]                             invokeRestart(restart)
[01:28:34.672]                             muffled <- TRUE
[01:28:34.672]                             break
[01:28:34.672]                           }
[01:28:34.672]                         }
[01:28:34.672]                       }
[01:28:34.672]                       invisible(muffled)
[01:28:34.672]                     }
[01:28:34.672]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.672]                   }
[01:28:34.672]                 }
[01:28:34.672]             }
[01:28:34.672]         }))
[01:28:34.672]     }, error = function(ex) {
[01:28:34.672]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:34.672]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.672]                 ...future.rng), started = ...future.startTime, 
[01:28:34.672]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:34.672]             version = "1.8"), class = "FutureResult")
[01:28:34.672]     }, finally = {
[01:28:34.672]         if (!identical(...future.workdir, getwd())) 
[01:28:34.672]             setwd(...future.workdir)
[01:28:34.672]         {
[01:28:34.672]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:34.672]                 ...future.oldOptions$nwarnings <- NULL
[01:28:34.672]             }
[01:28:34.672]             base::options(...future.oldOptions)
[01:28:34.672]             if (.Platform$OS.type == "windows") {
[01:28:34.672]                 old_names <- names(...future.oldEnvVars)
[01:28:34.672]                 envs <- base::Sys.getenv()
[01:28:34.672]                 names <- names(envs)
[01:28:34.672]                 common <- intersect(names, old_names)
[01:28:34.672]                 added <- setdiff(names, old_names)
[01:28:34.672]                 removed <- setdiff(old_names, names)
[01:28:34.672]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:34.672]                   envs[common]]
[01:28:34.672]                 NAMES <- toupper(changed)
[01:28:34.672]                 args <- list()
[01:28:34.672]                 for (kk in seq_along(NAMES)) {
[01:28:34.672]                   name <- changed[[kk]]
[01:28:34.672]                   NAME <- NAMES[[kk]]
[01:28:34.672]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.672]                     next
[01:28:34.672]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.672]                 }
[01:28:34.672]                 NAMES <- toupper(added)
[01:28:34.672]                 for (kk in seq_along(NAMES)) {
[01:28:34.672]                   name <- added[[kk]]
[01:28:34.672]                   NAME <- NAMES[[kk]]
[01:28:34.672]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.672]                     next
[01:28:34.672]                   args[[name]] <- ""
[01:28:34.672]                 }
[01:28:34.672]                 NAMES <- toupper(removed)
[01:28:34.672]                 for (kk in seq_along(NAMES)) {
[01:28:34.672]                   name <- removed[[kk]]
[01:28:34.672]                   NAME <- NAMES[[kk]]
[01:28:34.672]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.672]                     next
[01:28:34.672]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.672]                 }
[01:28:34.672]                 if (length(args) > 0) 
[01:28:34.672]                   base::do.call(base::Sys.setenv, args = args)
[01:28:34.672]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:34.672]             }
[01:28:34.672]             else {
[01:28:34.672]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:34.672]             }
[01:28:34.672]             {
[01:28:34.672]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:34.672]                   0L) {
[01:28:34.672]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:34.672]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:34.672]                   base::options(opts)
[01:28:34.672]                 }
[01:28:34.672]                 {
[01:28:34.672]                   {
[01:28:34.672]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:34.672]                     NULL
[01:28:34.672]                   }
[01:28:34.672]                   options(future.plan = NULL)
[01:28:34.672]                   if (is.na(NA_character_)) 
[01:28:34.672]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.672]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:34.672]                   future::plan(list(a = function (..., workers = availableCores(), 
[01:28:34.672]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:34.672]                     envir = parent.frame()) 
[01:28:34.672]                   {
[01:28:34.672]                     if (is.function(workers)) 
[01:28:34.672]                       workers <- workers()
[01:28:34.672]                     workers <- structure(as.integer(workers), 
[01:28:34.672]                       class = class(workers))
[01:28:34.672]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:34.672]                       workers >= 1)
[01:28:34.672]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:34.672]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:34.672]                     }
[01:28:34.672]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:34.672]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:34.672]                       envir = envir)
[01:28:34.672]                     if (!future$lazy) 
[01:28:34.672]                       future <- run(future)
[01:28:34.672]                     invisible(future)
[01:28:34.672]                   }, b = function (..., envir = parent.frame()) 
[01:28:34.672]                   {
[01:28:34.672]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.672]                     if (!future$lazy) 
[01:28:34.672]                       future <- run(future)
[01:28:34.672]                     invisible(future)
[01:28:34.672]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.672]                 }
[01:28:34.672]             }
[01:28:34.672]         }
[01:28:34.672]     })
[01:28:34.672]     if (TRUE) {
[01:28:34.672]         base::sink(type = "output", split = FALSE)
[01:28:34.672]         if (TRUE) {
[01:28:34.672]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:34.672]         }
[01:28:34.672]         else {
[01:28:34.672]             ...future.result["stdout"] <- base::list(NULL)
[01:28:34.672]         }
[01:28:34.672]         base::close(...future.stdout)
[01:28:34.672]         ...future.stdout <- NULL
[01:28:34.672]     }
[01:28:34.672]     ...future.result$conditions <- ...future.conditions
[01:28:34.672]     ...future.result$finished <- base::Sys.time()
[01:28:34.672]     ...future.result
[01:28:34.672] }
[01:28:34.679] Exporting 2 global objects (55.46 KiB) to cluster node #1 ...
[01:28:34.680] Exporting 'nested' (55.34 KiB) to cluster node #1 ...
[01:28:34.681] Exporting 'nested' (55.34 KiB) to cluster node #1 ... DONE
[01:28:34.681] Exporting 'strategy2' (120 bytes) to cluster node #1 ...
[01:28:34.682] Exporting 'strategy2' (120 bytes) to cluster node #1 ... DONE
[01:28:34.682] Exporting 2 global objects (55.46 KiB) to cluster node #1 ... DONE
[01:28:34.683] MultisessionFuture started
[01:28:34.683] - Launch lazy future ... done
[01:28:34.683] run() for 'MultisessionFuture' ... done
[01:28:34.684] result() for ClusterFuture ...
[01:28:34.684] receiveMessageFromWorker() for ClusterFuture ...
[01:28:34.684] - Validating connection of MultisessionFuture
[01:28:34.758] - received message: FutureResult
[01:28:34.758] - Received FutureResult
[01:28:34.759] - Erased future from FutureRegistry
[01:28:34.759] result() for ClusterFuture ...
[01:28:34.759] - result already collected: FutureResult
[01:28:34.759] result() for ClusterFuture ... done
[01:28:34.759] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:34.760] result() for ClusterFuture ... done
[01:28:34.760] result() for ClusterFuture ...
[01:28:34.760] - result already collected: FutureResult
[01:28:34.760] 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"
[01:28:34.767] getGlobalsAndPackages() ...
[01:28:34.767] Searching for globals...
[01:28:34.769] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[01:28:34.769] Searching for globals ... DONE
[01:28:34.769] Resolving globals: FALSE
[01:28:34.770] The total size of the 1 globals is 128 bytes (128 bytes)
[01:28:34.771] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 128 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (128 bytes of class 'list')
[01:28:34.771] - globals: [1] 'data'
[01:28:34.771] - packages: [1] 'future'
[01:28:34.771] getGlobalsAndPackages() ... DONE
[01:28:34.772] run() for 'Future' ...
[01:28:34.772] - state: 'created'
[01:28:34.772] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:34.788] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:34.788] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:34.788]   - Field: 'node'
[01:28:34.788]   - Field: 'label'
[01:28:34.789]   - Field: 'local'
[01:28:34.789]   - Field: 'owner'
[01:28:34.789]   - Field: 'envir'
[01:28:34.789]   - Field: 'workers'
[01:28:34.789]   - Field: 'packages'
[01:28:34.790]   - Field: 'gc'
[01:28:34.790]   - Field: 'conditions'
[01:28:34.790]   - Field: 'persistent'
[01:28:34.790]   - Field: 'expr'
[01:28:34.790]   - Field: 'uuid'
[01:28:34.790]   - Field: 'seed'
[01:28:34.791]   - Field: 'version'
[01:28:34.791]   - Field: 'result'
[01:28:34.791]   - Field: 'asynchronous'
[01:28:34.791]   - Field: 'calls'
[01:28:34.791]   - Field: 'globals'
[01:28:34.791]   - Field: 'stdout'
[01:28:34.792]   - Field: 'earlySignal'
[01:28:34.792]   - Field: 'lazy'
[01:28:34.792]   - Field: 'state'
[01:28:34.792] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:34.793] - Launch lazy future ...
[01:28:34.793] Packages needed by the future expression (n = 1): 'future'
[01:28:34.793] Packages needed by future strategies (n = 1): 'future'
[01:28:34.794] {
[01:28:34.794]     {
[01:28:34.794]         {
[01:28:34.794]             ...future.startTime <- base::Sys.time()
[01:28:34.794]             {
[01:28:34.794]                 {
[01:28:34.794]                   {
[01:28:34.794]                     {
[01:28:34.794]                       {
[01:28:34.794]                         base::local({
[01:28:34.794]                           has_future <- base::requireNamespace("future", 
[01:28:34.794]                             quietly = TRUE)
[01:28:34.794]                           if (has_future) {
[01:28:34.794]                             ns <- base::getNamespace("future")
[01:28:34.794]                             version <- ns[[".package"]][["version"]]
[01:28:34.794]                             if (is.null(version)) 
[01:28:34.794]                               version <- utils::packageVersion("future")
[01:28:34.794]                           }
[01:28:34.794]                           else {
[01:28:34.794]                             version <- NULL
[01:28:34.794]                           }
[01:28:34.794]                           if (!has_future || version < "1.8.0") {
[01:28:34.794]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:34.794]                               "", base::R.version$version.string), 
[01:28:34.794]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:34.794]                                 base::R.version$platform, 8 * 
[01:28:34.794]                                   base::.Machine$sizeof.pointer), 
[01:28:34.794]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:34.794]                                 "release", "version")], collapse = " "), 
[01:28:34.794]                               hostname = base::Sys.info()[["nodename"]])
[01:28:34.794]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:34.794]                               info)
[01:28:34.794]                             info <- base::paste(info, collapse = "; ")
[01:28:34.794]                             if (!has_future) {
[01:28:34.794]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:34.794]                                 info)
[01:28:34.794]                             }
[01:28:34.794]                             else {
[01:28:34.794]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:34.794]                                 info, version)
[01:28:34.794]                             }
[01:28:34.794]                             base::stop(msg)
[01:28:34.794]                           }
[01:28:34.794]                         })
[01:28:34.794]                       }
[01:28:34.794]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:34.794]                       base::options(mc.cores = 1L)
[01:28:34.794]                     }
[01:28:34.794]                     base::local({
[01:28:34.794]                       for (pkg in "future") {
[01:28:34.794]                         base::loadNamespace(pkg)
[01:28:34.794]                         base::library(pkg, character.only = TRUE)
[01:28:34.794]                       }
[01:28:34.794]                     })
[01:28:34.794]                   }
[01:28:34.794]                   options(future.plan = NULL)
[01:28:34.794]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.794]                   future::plan(list(b = function (..., envir = parent.frame()) 
[01:28:34.794]                   {
[01:28:34.794]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.794]                     if (!future$lazy) 
[01:28:34.794]                       future <- run(future)
[01:28:34.794]                     invisible(future)
[01:28:34.794]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.794]                 }
[01:28:34.794]                 ...future.workdir <- getwd()
[01:28:34.794]             }
[01:28:34.794]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:34.794]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:34.794]         }
[01:28:34.794]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:34.794]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:34.794]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:34.794]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:34.794]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:34.794]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:34.794]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:34.794]             base::names(...future.oldOptions))
[01:28:34.794]     }
[01:28:34.794]     if (FALSE) {
[01:28:34.794]     }
[01:28:34.794]     else {
[01:28:34.794]         if (TRUE) {
[01:28:34.794]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:34.794]                 open = "w")
[01:28:34.794]         }
[01:28:34.794]         else {
[01:28:34.794]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:34.794]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:34.794]         }
[01:28:34.794]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:34.794]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:34.794]             base::sink(type = "output", split = FALSE)
[01:28:34.794]             base::close(...future.stdout)
[01:28:34.794]         }, add = TRUE)
[01:28:34.794]     }
[01:28:34.794]     ...future.frame <- base::sys.nframe()
[01:28:34.794]     ...future.conditions <- base::list()
[01:28:34.794]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:34.794]     if (FALSE) {
[01:28:34.794]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:34.794]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:34.794]     }
[01:28:34.794]     ...future.result <- base::tryCatch({
[01:28:34.794]         base::withCallingHandlers({
[01:28:34.794]             ...future.value <- base::withVisible(base::local({
[01:28:34.794]                 ...future.makeSendCondition <- base::local({
[01:28:34.794]                   sendCondition <- NULL
[01:28:34.794]                   function(frame = 1L) {
[01:28:34.794]                     if (is.function(sendCondition)) 
[01:28:34.794]                       return(sendCondition)
[01:28:34.794]                     ns <- getNamespace("parallel")
[01:28:34.794]                     if (exists("sendData", mode = "function", 
[01:28:34.794]                       envir = ns)) {
[01:28:34.794]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:34.794]                         envir = ns)
[01:28:34.794]                       envir <- sys.frame(frame)
[01:28:34.794]                       master <- NULL
[01:28:34.794]                       while (!identical(envir, .GlobalEnv) && 
[01:28:34.794]                         !identical(envir, emptyenv())) {
[01:28:34.794]                         if (exists("master", mode = "list", envir = envir, 
[01:28:34.794]                           inherits = FALSE)) {
[01:28:34.794]                           master <- get("master", mode = "list", 
[01:28:34.794]                             envir = envir, inherits = FALSE)
[01:28:34.794]                           if (inherits(master, c("SOCKnode", 
[01:28:34.794]                             "SOCK0node"))) {
[01:28:34.794]                             sendCondition <<- function(cond) {
[01:28:34.794]                               data <- list(type = "VALUE", value = cond, 
[01:28:34.794]                                 success = TRUE)
[01:28:34.794]                               parallel_sendData(master, data)
[01:28:34.794]                             }
[01:28:34.794]                             return(sendCondition)
[01:28:34.794]                           }
[01:28:34.794]                         }
[01:28:34.794]                         frame <- frame + 1L
[01:28:34.794]                         envir <- sys.frame(frame)
[01:28:34.794]                       }
[01:28:34.794]                     }
[01:28:34.794]                     sendCondition <<- function(cond) NULL
[01:28:34.794]                   }
[01:28:34.794]                 })
[01:28:34.794]                 withCallingHandlers({
[01:28:34.794]                   {
[01:28:34.794]                     value(future(subset(data, a == 2)))
[01:28:34.794]                   }
[01:28:34.794]                 }, immediateCondition = function(cond) {
[01:28:34.794]                   sendCondition <- ...future.makeSendCondition()
[01:28:34.794]                   sendCondition(cond)
[01:28:34.794]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.794]                   {
[01:28:34.794]                     inherits <- base::inherits
[01:28:34.794]                     invokeRestart <- base::invokeRestart
[01:28:34.794]                     is.null <- base::is.null
[01:28:34.794]                     muffled <- FALSE
[01:28:34.794]                     if (inherits(cond, "message")) {
[01:28:34.794]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:34.794]                       if (muffled) 
[01:28:34.794]                         invokeRestart("muffleMessage")
[01:28:34.794]                     }
[01:28:34.794]                     else if (inherits(cond, "warning")) {
[01:28:34.794]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:34.794]                       if (muffled) 
[01:28:34.794]                         invokeRestart("muffleWarning")
[01:28:34.794]                     }
[01:28:34.794]                     else if (inherits(cond, "condition")) {
[01:28:34.794]                       if (!is.null(pattern)) {
[01:28:34.794]                         computeRestarts <- base::computeRestarts
[01:28:34.794]                         grepl <- base::grepl
[01:28:34.794]                         restarts <- computeRestarts(cond)
[01:28:34.794]                         for (restart in restarts) {
[01:28:34.794]                           name <- restart$name
[01:28:34.794]                           if (is.null(name)) 
[01:28:34.794]                             next
[01:28:34.794]                           if (!grepl(pattern, name)) 
[01:28:34.794]                             next
[01:28:34.794]                           invokeRestart(restart)
[01:28:34.794]                           muffled <- TRUE
[01:28:34.794]                           break
[01:28:34.794]                         }
[01:28:34.794]                       }
[01:28:34.794]                     }
[01:28:34.794]                     invisible(muffled)
[01:28:34.794]                   }
[01:28:34.794]                   muffleCondition(cond)
[01:28:34.794]                 })
[01:28:34.794]             }))
[01:28:34.794]             future::FutureResult(value = ...future.value$value, 
[01:28:34.794]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.794]                   ...future.rng), globalenv = if (FALSE) 
[01:28:34.794]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:34.794]                     ...future.globalenv.names))
[01:28:34.794]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:34.794]         }, condition = base::local({
[01:28:34.794]             c <- base::c
[01:28:34.794]             inherits <- base::inherits
[01:28:34.794]             invokeRestart <- base::invokeRestart
[01:28:34.794]             length <- base::length
[01:28:34.794]             list <- base::list
[01:28:34.794]             seq.int <- base::seq.int
[01:28:34.794]             signalCondition <- base::signalCondition
[01:28:34.794]             sys.calls <- base::sys.calls
[01:28:34.794]             `[[` <- base::`[[`
[01:28:34.794]             `+` <- base::`+`
[01:28:34.794]             `<<-` <- base::`<<-`
[01:28:34.794]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:34.794]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:34.794]                   3L)]
[01:28:34.794]             }
[01:28:34.794]             function(cond) {
[01:28:34.794]                 is_error <- inherits(cond, "error")
[01:28:34.794]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:34.794]                   NULL)
[01:28:34.794]                 if (is_error) {
[01:28:34.794]                   sessionInformation <- function() {
[01:28:34.794]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:34.794]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:34.794]                       search = base::search(), system = base::Sys.info())
[01:28:34.794]                   }
[01:28:34.794]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.794]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:34.794]                     cond$call), session = sessionInformation(), 
[01:28:34.794]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:34.794]                   signalCondition(cond)
[01:28:34.794]                 }
[01:28:34.794]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:34.794]                 "immediateCondition"))) {
[01:28:34.794]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:34.794]                   ...future.conditions[[length(...future.conditions) + 
[01:28:34.794]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:34.794]                   if (TRUE && !signal) {
[01:28:34.794]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.794]                     {
[01:28:34.794]                       inherits <- base::inherits
[01:28:34.794]                       invokeRestart <- base::invokeRestart
[01:28:34.794]                       is.null <- base::is.null
[01:28:34.794]                       muffled <- FALSE
[01:28:34.794]                       if (inherits(cond, "message")) {
[01:28:34.794]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.794]                         if (muffled) 
[01:28:34.794]                           invokeRestart("muffleMessage")
[01:28:34.794]                       }
[01:28:34.794]                       else if (inherits(cond, "warning")) {
[01:28:34.794]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.794]                         if (muffled) 
[01:28:34.794]                           invokeRestart("muffleWarning")
[01:28:34.794]                       }
[01:28:34.794]                       else if (inherits(cond, "condition")) {
[01:28:34.794]                         if (!is.null(pattern)) {
[01:28:34.794]                           computeRestarts <- base::computeRestarts
[01:28:34.794]                           grepl <- base::grepl
[01:28:34.794]                           restarts <- computeRestarts(cond)
[01:28:34.794]                           for (restart in restarts) {
[01:28:34.794]                             name <- restart$name
[01:28:34.794]                             if (is.null(name)) 
[01:28:34.794]                               next
[01:28:34.794]                             if (!grepl(pattern, name)) 
[01:28:34.794]                               next
[01:28:34.794]                             invokeRestart(restart)
[01:28:34.794]                             muffled <- TRUE
[01:28:34.794]                             break
[01:28:34.794]                           }
[01:28:34.794]                         }
[01:28:34.794]                       }
[01:28:34.794]                       invisible(muffled)
[01:28:34.794]                     }
[01:28:34.794]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.794]                   }
[01:28:34.794]                 }
[01:28:34.794]                 else {
[01:28:34.794]                   if (TRUE) {
[01:28:34.794]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:34.794]                     {
[01:28:34.794]                       inherits <- base::inherits
[01:28:34.794]                       invokeRestart <- base::invokeRestart
[01:28:34.794]                       is.null <- base::is.null
[01:28:34.794]                       muffled <- FALSE
[01:28:34.794]                       if (inherits(cond, "message")) {
[01:28:34.794]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:34.794]                         if (muffled) 
[01:28:34.794]                           invokeRestart("muffleMessage")
[01:28:34.794]                       }
[01:28:34.794]                       else if (inherits(cond, "warning")) {
[01:28:34.794]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:34.794]                         if (muffled) 
[01:28:34.794]                           invokeRestart("muffleWarning")
[01:28:34.794]                       }
[01:28:34.794]                       else if (inherits(cond, "condition")) {
[01:28:34.794]                         if (!is.null(pattern)) {
[01:28:34.794]                           computeRestarts <- base::computeRestarts
[01:28:34.794]                           grepl <- base::grepl
[01:28:34.794]                           restarts <- computeRestarts(cond)
[01:28:34.794]                           for (restart in restarts) {
[01:28:34.794]                             name <- restart$name
[01:28:34.794]                             if (is.null(name)) 
[01:28:34.794]                               next
[01:28:34.794]                             if (!grepl(pattern, name)) 
[01:28:34.794]                               next
[01:28:34.794]                             invokeRestart(restart)
[01:28:34.794]                             muffled <- TRUE
[01:28:34.794]                             break
[01:28:34.794]                           }
[01:28:34.794]                         }
[01:28:34.794]                       }
[01:28:34.794]                       invisible(muffled)
[01:28:34.794]                     }
[01:28:34.794]                     muffleCondition(cond, pattern = "^muffle")
[01:28:34.794]                   }
[01:28:34.794]                 }
[01:28:34.794]             }
[01:28:34.794]         }))
[01:28:34.794]     }, error = function(ex) {
[01:28:34.794]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:34.794]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:34.794]                 ...future.rng), started = ...future.startTime, 
[01:28:34.794]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:34.794]             version = "1.8"), class = "FutureResult")
[01:28:34.794]     }, finally = {
[01:28:34.794]         if (!identical(...future.workdir, getwd())) 
[01:28:34.794]             setwd(...future.workdir)
[01:28:34.794]         {
[01:28:34.794]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:34.794]                 ...future.oldOptions$nwarnings <- NULL
[01:28:34.794]             }
[01:28:34.794]             base::options(...future.oldOptions)
[01:28:34.794]             if (.Platform$OS.type == "windows") {
[01:28:34.794]                 old_names <- names(...future.oldEnvVars)
[01:28:34.794]                 envs <- base::Sys.getenv()
[01:28:34.794]                 names <- names(envs)
[01:28:34.794]                 common <- intersect(names, old_names)
[01:28:34.794]                 added <- setdiff(names, old_names)
[01:28:34.794]                 removed <- setdiff(old_names, names)
[01:28:34.794]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:34.794]                   envs[common]]
[01:28:34.794]                 NAMES <- toupper(changed)
[01:28:34.794]                 args <- list()
[01:28:34.794]                 for (kk in seq_along(NAMES)) {
[01:28:34.794]                   name <- changed[[kk]]
[01:28:34.794]                   NAME <- NAMES[[kk]]
[01:28:34.794]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.794]                     next
[01:28:34.794]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.794]                 }
[01:28:34.794]                 NAMES <- toupper(added)
[01:28:34.794]                 for (kk in seq_along(NAMES)) {
[01:28:34.794]                   name <- added[[kk]]
[01:28:34.794]                   NAME <- NAMES[[kk]]
[01:28:34.794]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.794]                     next
[01:28:34.794]                   args[[name]] <- ""
[01:28:34.794]                 }
[01:28:34.794]                 NAMES <- toupper(removed)
[01:28:34.794]                 for (kk in seq_along(NAMES)) {
[01:28:34.794]                   name <- removed[[kk]]
[01:28:34.794]                   NAME <- NAMES[[kk]]
[01:28:34.794]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:34.794]                     next
[01:28:34.794]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:34.794]                 }
[01:28:34.794]                 if (length(args) > 0) 
[01:28:34.794]                   base::do.call(base::Sys.setenv, args = args)
[01:28:34.794]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:34.794]             }
[01:28:34.794]             else {
[01:28:34.794]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:34.794]             }
[01:28:34.794]             {
[01:28:34.794]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:34.794]                   0L) {
[01:28:34.794]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:34.794]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:34.794]                   base::options(opts)
[01:28:34.794]                 }
[01:28:34.794]                 {
[01:28:34.794]                   {
[01:28:34.794]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:34.794]                     NULL
[01:28:34.794]                   }
[01:28:34.794]                   options(future.plan = NULL)
[01:28:34.794]                   if (is.na(NA_character_)) 
[01:28:34.794]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:34.794]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:34.794]                   future::plan(list(a = function (..., workers = availableCores(), 
[01:28:34.794]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:34.794]                     envir = parent.frame()) 
[01:28:34.794]                   {
[01:28:34.794]                     if (is.function(workers)) 
[01:28:34.794]                       workers <- workers()
[01:28:34.794]                     workers <- structure(as.integer(workers), 
[01:28:34.794]                       class = class(workers))
[01:28:34.794]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:34.794]                       workers >= 1)
[01:28:34.794]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:34.794]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:34.794]                     }
[01:28:34.794]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:34.794]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:34.794]                       envir = envir)
[01:28:34.794]                     if (!future$lazy) 
[01:28:34.794]                       future <- run(future)
[01:28:34.794]                     invisible(future)
[01:28:34.794]                   }, b = function (..., envir = parent.frame()) 
[01:28:34.794]                   {
[01:28:34.794]                     future <- SequentialFuture(..., envir = envir)
[01:28:34.794]                     if (!future$lazy) 
[01:28:34.794]                       future <- run(future)
[01:28:34.794]                     invisible(future)
[01:28:34.794]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:34.794]                 }
[01:28:34.794]             }
[01:28:34.794]         }
[01:28:34.794]     })
[01:28:34.794]     if (TRUE) {
[01:28:34.794]         base::sink(type = "output", split = FALSE)
[01:28:34.794]         if (TRUE) {
[01:28:34.794]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:34.794]         }
[01:28:34.794]         else {
[01:28:34.794]             ...future.result["stdout"] <- base::list(NULL)
[01:28:34.794]         }
[01:28:34.794]         base::close(...future.stdout)
[01:28:34.794]         ...future.stdout <- NULL
[01:28:34.794]     }
[01:28:34.794]     ...future.result$conditions <- ...future.conditions
[01:28:34.794]     ...future.result$finished <- base::Sys.time()
[01:28:34.794]     ...future.result
[01:28:34.794] }
[01:28:34.801] Exporting 1 global objects (128 bytes) to cluster node #1 ...
[01:28:34.801] Exporting 'data' (128 bytes) to cluster node #1 ...
[01:28:34.802] Exporting 'data' (128 bytes) to cluster node #1 ... DONE
[01:28:34.802] Exporting 1 global objects (128 bytes) to cluster node #1 ... DONE
[01:28:34.803] MultisessionFuture started
[01:28:34.803] - Launch lazy future ... done
[01:28:34.803] run() for 'MultisessionFuture' ... done
[01:28:34.803] result() for ClusterFuture ...
[01:28:34.803] receiveMessageFromWorker() for ClusterFuture ...
[01:28:34.804] - Validating connection of MultisessionFuture
[01:28:34.843] - received message: FutureResult
[01:28:34.844] - Received FutureResult
[01:28:34.844] - Erased future from FutureRegistry
[01:28:34.844] result() for ClusterFuture ...
[01:28:34.844] - result already collected: FutureResult
[01:28:34.844] result() for ClusterFuture ... done
[01:28:34.845] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:34.845] result() for ClusterFuture ... done
[01:28:34.845] result() for ClusterFuture ...
[01:28:34.845] - result already collected: FutureResult
[01:28:34.845] result() for ClusterFuture ... done
- plan(list('multisession', 'sequential')) ... DONE
- plan(list('multisession', 'multisession')) ...
[01:28:34.846] plan(): Setting new future strategy stack:
[01:28:34.846] List of future strategies:
[01:28:34.846] 1. multisession:
[01:28:34.846]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.846]    - tweaked: FALSE
[01:28:34.846]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.846] 2. multisession:
[01:28:34.846]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.846]    - tweaked: FALSE
[01:28:34.846]    - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.847] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:34.847] multisession:
[01:28:34.847] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:34.847] - tweaked: FALSE
[01:28:34.847] - call: plan(list(a = strategy1, b = strategy2))
[01:28:34.850] getGlobalsAndPackages() ...
[01:28:34.850] Not searching for globals
[01:28:34.850] - globals: [0] <none>
[01:28:34.850] getGlobalsAndPackages() ... DONE
[01:28:34.851] [local output] makeClusterPSOCK() ...
[01:28:34.852] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:34.855] [local output] Base port: 30796
[01:28:34.856] [local output] Getting setup options for 2 cluster nodes ...
[01:28:34.856] [local output]  - Node 1 of 2 ...
[01:28:34.856] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:34.858] [local output] Rscript port: 30796

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

[01:28:34.860] [local output] Rscript port: 30796

[01:28:34.861] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:34.861] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:34.861] [local output] Setting up PSOCK nodes in parallel
[01:28:34.862] List of 36
[01:28:34.862]  $ worker          : chr "localhost"
[01:28:34.862]   ..- attr(*, "localhost")= logi TRUE
[01:28:34.862]  $ master          : chr "localhost"
[01:28:34.862]  $ port            : int 30796
[01:28:34.862]  $ connectTimeout  : num 120
[01:28:34.862]  $ timeout         : num 120
[01:28:34.862]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:34.862]  $ homogeneous     : logi TRUE
[01:28:34.862]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=nested_futures.R:8736:CRANWIN3:C"| __truncated__
[01:28:34.862]  $ rscript_envs    : NULL
[01:28:34.862]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:34.862]  $ rscript_startup : NULL
[01:28:34.862]  $ rscript_sh      : chr "cmd"
[01:28:34.862]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:34.862]  $ methods         : logi TRUE
[01:28:34.862]  $ socketOptions   : chr "no-delay"
[01:28:34.862]  $ useXDR          : logi FALSE
[01:28:34.862]  $ outfile         : chr "/dev/null"
[01:28:34.862]  $ renice          : int NA
[01:28:34.862]  $ rshcmd          : NULL
[01:28:34.862]  $ user            : chr(0) 
[01:28:34.862]  $ revtunnel       : logi FALSE
[01:28:34.862]  $ rshlogfile      : NULL
[01:28:34.862]  $ rshopts         : chr(0) 
[01:28:34.862]  $ rank            : int 1
[01:28:34.862]  $ manual          : logi FALSE
[01:28:34.862]  $ dryrun          : logi FALSE
[01:28:34.862]  $ quiet           : logi FALSE
[01:28:34.862]  $ setup_strategy  : chr "parallel"
[01:28:34.862]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:34.862]  $ pidfile         : chr "D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.22207e5758f7.pid"
[01:28:34.862]  $ rshcmd_label    : NULL
[01:28:34.862]  $ rsh_call        : NULL
[01:28:34.862]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:34.862]  $ localMachine    : logi TRUE
[01:28:34.862]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:34.862]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:34.862]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:34.862]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:34.862]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:34.862]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:34.862]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:34.862]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:34.862]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:34.862]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:34.862]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:34.862]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:34.862]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:34.862]  $ arguments       :List of 28
[01:28:34.862]   ..$ worker          : chr "localhost"
[01:28:34.862]   ..$ master          : NULL
[01:28:34.862]   ..$ port            : int 30796
[01:28:34.862]   ..$ connectTimeout  : num 120
[01:28:34.862]   ..$ timeout         : num 120
[01:28:34.862]   ..$ rscript         : NULL
[01:28:34.862]   ..$ homogeneous     : NULL
[01:28:34.862]   ..$ rscript_args    : NULL
[01:28:34.862]   ..$ rscript_envs    : NULL
[01:28:34.862]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:34.862]   ..$ rscript_startup : NULL
[01:28:34.862]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:34.862]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:34.862]   ..$ methods         : logi TRUE
[01:28:34.862]   ..$ socketOptions   : chr "no-delay"
[01:28:34.862]   ..$ useXDR          : logi FALSE
[01:28:34.862]   ..$ outfile         : chr "/dev/null"
[01:28:34.862]   ..$ renice          : int NA
[01:28:34.862]   ..$ rshcmd          : NULL
[01:28:34.862]   ..$ user            : NULL
[01:28:34.862]   ..$ revtunnel       : logi NA
[01:28:34.862]   ..$ rshlogfile      : NULL
[01:28:34.862]   ..$ rshopts         : NULL
[01:28:34.862]   ..$ rank            : int 1
[01:28:34.862]   ..$ manual          : logi FALSE
[01:28:34.862]   ..$ dryrun          : logi FALSE
[01:28:34.862]   ..$ quiet           : logi FALSE
[01:28:34.862]   ..$ setup_strategy  : chr "parallel"
[01:28:34.862]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:34.887] [local output] System call to launch all workers:
[01:28:34.887] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=nested_futures.R:8736:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpG4uU7n/worker.rank=1.parallelly.parent=8736.22207e5758f7.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=30796 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:34.887] [local output] Starting PSOCK main server
[01:28:34.893] [local output] Workers launched
[01:28:34.893] [local output] Waiting for workers to connect back
[01:28:34.894]  - [local output] 0 workers out of 2 ready
[01:28:35.108]  - [local output] 0 workers out of 2 ready
[01:28:35.108]  - [local output] 1 workers out of 2 ready
[01:28:35.111]  - [local output] 1 workers out of 2 ready
[01:28:35.111]  - [local output] 2 workers out of 2 ready
[01:28:35.112] [local output] Launching of workers completed
[01:28:35.112] [local output] Collecting session information from workers
[01:28:35.113] [local output]  - Worker #1 of 2
[01:28:35.113] [local output]  - Worker #2 of 2
[01:28:35.113] [local output] makeClusterPSOCK() ... done
[01:28:35.126] Packages needed by the future expression (n = 0): <none>
[01:28:35.127] Packages needed by future strategies (n = 1): 'future'
[01:28:35.127] {
[01:28:35.127]     {
[01:28:35.127]         {
[01:28:35.127]             ...future.startTime <- base::Sys.time()
[01:28:35.127]             {
[01:28:35.127]                 {
[01:28:35.127]                   {
[01:28:35.127]                     {
[01:28:35.127]                       {
[01:28:35.127]                         base::local({
[01:28:35.127]                           has_future <- base::requireNamespace("future", 
[01:28:35.127]                             quietly = TRUE)
[01:28:35.127]                           if (has_future) {
[01:28:35.127]                             ns <- base::getNamespace("future")
[01:28:35.127]                             version <- ns[[".package"]][["version"]]
[01:28:35.127]                             if (is.null(version)) 
[01:28:35.127]                               version <- utils::packageVersion("future")
[01:28:35.127]                           }
[01:28:35.127]                           else {
[01:28:35.127]                             version <- NULL
[01:28:35.127]                           }
[01:28:35.127]                           if (!has_future || version < "1.8.0") {
[01:28:35.127]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:35.127]                               "", base::R.version$version.string), 
[01:28:35.127]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:35.127]                                 base::R.version$platform, 8 * 
[01:28:35.127]                                   base::.Machine$sizeof.pointer), 
[01:28:35.127]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:35.127]                                 "release", "version")], collapse = " "), 
[01:28:35.127]                               hostname = base::Sys.info()[["nodename"]])
[01:28:35.127]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:35.127]                               info)
[01:28:35.127]                             info <- base::paste(info, collapse = "; ")
[01:28:35.127]                             if (!has_future) {
[01:28:35.127]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:35.127]                                 info)
[01:28:35.127]                             }
[01:28:35.127]                             else {
[01:28:35.127]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:35.127]                                 info, version)
[01:28:35.127]                             }
[01:28:35.127]                             base::stop(msg)
[01:28:35.127]                           }
[01:28:35.127]                         })
[01:28:35.127]                       }
[01:28:35.127]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:35.127]                       base::options(mc.cores = 1L)
[01:28:35.127]                     }
[01:28:35.127]                     base::local({
[01:28:35.127]                       for (pkg in "future") {
[01:28:35.127]                         base::loadNamespace(pkg)
[01:28:35.127]                         base::library(pkg, character.only = TRUE)
[01:28:35.127]                       }
[01:28:35.127]                     })
[01:28:35.127]                   }
[01:28:35.127]                   options(future.plan = NULL)
[01:28:35.127]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:35.127]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:35.127]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.127]                     envir = parent.frame()) 
[01:28:35.127]                   {
[01:28:35.127]                     if (is.function(workers)) 
[01:28:35.127]                       workers <- workers()
[01:28:35.127]                     workers <- structure(as.integer(workers), 
[01:28:35.127]                       class = class(workers))
[01:28:35.127]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.127]                       workers >= 1)
[01:28:35.127]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.127]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.127]                     }
[01:28:35.127]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.127]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.127]                       envir = envir)
[01:28:35.127]                     if (!future$lazy) 
[01:28:35.127]                       future <- run(future)
[01:28:35.127]                     invisible(future)
[01:28:35.127]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:35.127]                 }
[01:28:35.127]                 ...future.workdir <- getwd()
[01:28:35.127]             }
[01:28:35.127]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:35.127]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:35.127]         }
[01:28:35.127]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:35.127]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:35.127]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:35.127]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:35.127]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:35.127]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:35.127]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:35.127]             base::names(...future.oldOptions))
[01:28:35.127]     }
[01:28:35.127]     if (FALSE) {
[01:28:35.127]     }
[01:28:35.127]     else {
[01:28:35.127]         if (TRUE) {
[01:28:35.127]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:35.127]                 open = "w")
[01:28:35.127]         }
[01:28:35.127]         else {
[01:28:35.127]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:35.127]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:35.127]         }
[01:28:35.127]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:35.127]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:35.127]             base::sink(type = "output", split = FALSE)
[01:28:35.127]             base::close(...future.stdout)
[01:28:35.127]         }, add = TRUE)
[01:28:35.127]     }
[01:28:35.127]     ...future.frame <- base::sys.nframe()
[01:28:35.127]     ...future.conditions <- base::list()
[01:28:35.127]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:35.127]     if (FALSE) {
[01:28:35.127]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:35.127]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:35.127]     }
[01:28:35.127]     ...future.result <- base::tryCatch({
[01:28:35.127]         base::withCallingHandlers({
[01:28:35.127]             ...future.value <- base::withVisible(base::local({
[01:28:35.127]                 ...future.makeSendCondition <- base::local({
[01:28:35.127]                   sendCondition <- NULL
[01:28:35.127]                   function(frame = 1L) {
[01:28:35.127]                     if (is.function(sendCondition)) 
[01:28:35.127]                       return(sendCondition)
[01:28:35.127]                     ns <- getNamespace("parallel")
[01:28:35.127]                     if (exists("sendData", mode = "function", 
[01:28:35.127]                       envir = ns)) {
[01:28:35.127]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:35.127]                         envir = ns)
[01:28:35.127]                       envir <- sys.frame(frame)
[01:28:35.127]                       master <- NULL
[01:28:35.127]                       while (!identical(envir, .GlobalEnv) && 
[01:28:35.127]                         !identical(envir, emptyenv())) {
[01:28:35.127]                         if (exists("master", mode = "list", envir = envir, 
[01:28:35.127]                           inherits = FALSE)) {
[01:28:35.127]                           master <- get("master", mode = "list", 
[01:28:35.127]                             envir = envir, inherits = FALSE)
[01:28:35.127]                           if (inherits(master, c("SOCKnode", 
[01:28:35.127]                             "SOCK0node"))) {
[01:28:35.127]                             sendCondition <<- function(cond) {
[01:28:35.127]                               data <- list(type = "VALUE", value = cond, 
[01:28:35.127]                                 success = TRUE)
[01:28:35.127]                               parallel_sendData(master, data)
[01:28:35.127]                             }
[01:28:35.127]                             return(sendCondition)
[01:28:35.127]                           }
[01:28:35.127]                         }
[01:28:35.127]                         frame <- frame + 1L
[01:28:35.127]                         envir <- sys.frame(frame)
[01:28:35.127]                       }
[01:28:35.127]                     }
[01:28:35.127]                     sendCondition <<- function(cond) NULL
[01:28:35.127]                   }
[01:28:35.127]                 })
[01:28:35.127]                 withCallingHandlers({
[01:28:35.127]                   NA
[01:28:35.127]                 }, immediateCondition = function(cond) {
[01:28:35.127]                   sendCondition <- ...future.makeSendCondition()
[01:28:35.127]                   sendCondition(cond)
[01:28:35.127]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.127]                   {
[01:28:35.127]                     inherits <- base::inherits
[01:28:35.127]                     invokeRestart <- base::invokeRestart
[01:28:35.127]                     is.null <- base::is.null
[01:28:35.127]                     muffled <- FALSE
[01:28:35.127]                     if (inherits(cond, "message")) {
[01:28:35.127]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:35.127]                       if (muffled) 
[01:28:35.127]                         invokeRestart("muffleMessage")
[01:28:35.127]                     }
[01:28:35.127]                     else if (inherits(cond, "warning")) {
[01:28:35.127]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:35.127]                       if (muffled) 
[01:28:35.127]                         invokeRestart("muffleWarning")
[01:28:35.127]                     }
[01:28:35.127]                     else if (inherits(cond, "condition")) {
[01:28:35.127]                       if (!is.null(pattern)) {
[01:28:35.127]                         computeRestarts <- base::computeRestarts
[01:28:35.127]                         grepl <- base::grepl
[01:28:35.127]                         restarts <- computeRestarts(cond)
[01:28:35.127]                         for (restart in restarts) {
[01:28:35.127]                           name <- restart$name
[01:28:35.127]                           if (is.null(name)) 
[01:28:35.127]                             next
[01:28:35.127]                           if (!grepl(pattern, name)) 
[01:28:35.127]                             next
[01:28:35.127]                           invokeRestart(restart)
[01:28:35.127]                           muffled <- TRUE
[01:28:35.127]                           break
[01:28:35.127]                         }
[01:28:35.127]                       }
[01:28:35.127]                     }
[01:28:35.127]                     invisible(muffled)
[01:28:35.127]                   }
[01:28:35.127]                   muffleCondition(cond)
[01:28:35.127]                 })
[01:28:35.127]             }))
[01:28:35.127]             future::FutureResult(value = ...future.value$value, 
[01:28:35.127]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:35.127]                   ...future.rng), globalenv = if (FALSE) 
[01:28:35.127]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:35.127]                     ...future.globalenv.names))
[01:28:35.127]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:35.127]         }, condition = base::local({
[01:28:35.127]             c <- base::c
[01:28:35.127]             inherits <- base::inherits
[01:28:35.127]             invokeRestart <- base::invokeRestart
[01:28:35.127]             length <- base::length
[01:28:35.127]             list <- base::list
[01:28:35.127]             seq.int <- base::seq.int
[01:28:35.127]             signalCondition <- base::signalCondition
[01:28:35.127]             sys.calls <- base::sys.calls
[01:28:35.127]             `[[` <- base::`[[`
[01:28:35.127]             `+` <- base::`+`
[01:28:35.127]             `<<-` <- base::`<<-`
[01:28:35.127]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:35.127]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:35.127]                   3L)]
[01:28:35.127]             }
[01:28:35.127]             function(cond) {
[01:28:35.127]                 is_error <- inherits(cond, "error")
[01:28:35.127]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:35.127]                   NULL)
[01:28:35.127]                 if (is_error) {
[01:28:35.127]                   sessionInformation <- function() {
[01:28:35.127]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:35.127]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:35.127]                       search = base::search(), system = base::Sys.info())
[01:28:35.127]                   }
[01:28:35.127]                   ...future.conditions[[length(...future.conditions) + 
[01:28:35.127]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:35.127]                     cond$call), session = sessionInformation(), 
[01:28:35.127]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:35.127]                   signalCondition(cond)
[01:28:35.127]                 }
[01:28:35.127]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:35.127]                 "immediateCondition"))) {
[01:28:35.127]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:35.127]                   ...future.conditions[[length(...future.conditions) + 
[01:28:35.127]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:35.127]                   if (TRUE && !signal) {
[01:28:35.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.127]                     {
[01:28:35.127]                       inherits <- base::inherits
[01:28:35.127]                       invokeRestart <- base::invokeRestart
[01:28:35.127]                       is.null <- base::is.null
[01:28:35.127]                       muffled <- FALSE
[01:28:35.127]                       if (inherits(cond, "message")) {
[01:28:35.127]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:35.127]                         if (muffled) 
[01:28:35.127]                           invokeRestart("muffleMessage")
[01:28:35.127]                       }
[01:28:35.127]                       else if (inherits(cond, "warning")) {
[01:28:35.127]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:35.127]                         if (muffled) 
[01:28:35.127]                           invokeRestart("muffleWarning")
[01:28:35.127]                       }
[01:28:35.127]                       else if (inherits(cond, "condition")) {
[01:28:35.127]                         if (!is.null(pattern)) {
[01:28:35.127]                           computeRestarts <- base::computeRestarts
[01:28:35.127]                           grepl <- base::grepl
[01:28:35.127]                           restarts <- computeRestarts(cond)
[01:28:35.127]                           for (restart in restarts) {
[01:28:35.127]                             name <- restart$name
[01:28:35.127]                             if (is.null(name)) 
[01:28:35.127]                               next
[01:28:35.127]                             if (!grepl(pattern, name)) 
[01:28:35.127]                               next
[01:28:35.127]                             invokeRestart(restart)
[01:28:35.127]                             muffled <- TRUE
[01:28:35.127]                             break
[01:28:35.127]                           }
[01:28:35.127]                         }
[01:28:35.127]                       }
[01:28:35.127]                       invisible(muffled)
[01:28:35.127]                     }
[01:28:35.127]                     muffleCondition(cond, pattern = "^muffle")
[01:28:35.127]                   }
[01:28:35.127]                 }
[01:28:35.127]                 else {
[01:28:35.127]                   if (TRUE) {
[01:28:35.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.127]                     {
[01:28:35.127]                       inherits <- base::inherits
[01:28:35.127]                       invokeRestart <- base::invokeRestart
[01:28:35.127]                       is.null <- base::is.null
[01:28:35.127]                       muffled <- FALSE
[01:28:35.127]                       if (inherits(cond, "message")) {
[01:28:35.127]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:35.127]                         if (muffled) 
[01:28:35.127]                           invokeRestart("muffleMessage")
[01:28:35.127]                       }
[01:28:35.127]                       else if (inherits(cond, "warning")) {
[01:28:35.127]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:35.127]                         if (muffled) 
[01:28:35.127]                           invokeRestart("muffleWarning")
[01:28:35.127]                       }
[01:28:35.127]                       else if (inherits(cond, "condition")) {
[01:28:35.127]                         if (!is.null(pattern)) {
[01:28:35.127]                           computeRestarts <- base::computeRestarts
[01:28:35.127]                           grepl <- base::grepl
[01:28:35.127]                           restarts <- computeRestarts(cond)
[01:28:35.127]                           for (restart in restarts) {
[01:28:35.127]                             name <- restart$name
[01:28:35.127]                             if (is.null(name)) 
[01:28:35.127]                               next
[01:28:35.127]                             if (!grepl(pattern, name)) 
[01:28:35.127]                               next
[01:28:35.127]                             invokeRestart(restart)
[01:28:35.127]                             muffled <- TRUE
[01:28:35.127]                             break
[01:28:35.127]                           }
[01:28:35.127]                         }
[01:28:35.127]                       }
[01:28:35.127]                       invisible(muffled)
[01:28:35.127]                     }
[01:28:35.127]                     muffleCondition(cond, pattern = "^muffle")
[01:28:35.127]                   }
[01:28:35.127]                 }
[01:28:35.127]             }
[01:28:35.127]         }))
[01:28:35.127]     }, error = function(ex) {
[01:28:35.127]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:35.127]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:35.127]                 ...future.rng), started = ...future.startTime, 
[01:28:35.127]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:35.127]             version = "1.8"), class = "FutureResult")
[01:28:35.127]     }, finally = {
[01:28:35.127]         if (!identical(...future.workdir, getwd())) 
[01:28:35.127]             setwd(...future.workdir)
[01:28:35.127]         {
[01:28:35.127]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:35.127]                 ...future.oldOptions$nwarnings <- NULL
[01:28:35.127]             }
[01:28:35.127]             base::options(...future.oldOptions)
[01:28:35.127]             if (.Platform$OS.type == "windows") {
[01:28:35.127]                 old_names <- names(...future.oldEnvVars)
[01:28:35.127]                 envs <- base::Sys.getenv()
[01:28:35.127]                 names <- names(envs)
[01:28:35.127]                 common <- intersect(names, old_names)
[01:28:35.127]                 added <- setdiff(names, old_names)
[01:28:35.127]                 removed <- setdiff(old_names, names)
[01:28:35.127]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:35.127]                   envs[common]]
[01:28:35.127]                 NAMES <- toupper(changed)
[01:28:35.127]                 args <- list()
[01:28:35.127]                 for (kk in seq_along(NAMES)) {
[01:28:35.127]                   name <- changed[[kk]]
[01:28:35.127]                   NAME <- NAMES[[kk]]
[01:28:35.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.127]                     next
[01:28:35.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:35.127]                 }
[01:28:35.127]                 NAMES <- toupper(added)
[01:28:35.127]                 for (kk in seq_along(NAMES)) {
[01:28:35.127]                   name <- added[[kk]]
[01:28:35.127]                   NAME <- NAMES[[kk]]
[01:28:35.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.127]                     next
[01:28:35.127]                   args[[name]] <- ""
[01:28:35.127]                 }
[01:28:35.127]                 NAMES <- toupper(removed)
[01:28:35.127]                 for (kk in seq_along(NAMES)) {
[01:28:35.127]                   name <- removed[[kk]]
[01:28:35.127]                   NAME <- NAMES[[kk]]
[01:28:35.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.127]                     next
[01:28:35.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:35.127]                 }
[01:28:35.127]                 if (length(args) > 0) 
[01:28:35.127]                   base::do.call(base::Sys.setenv, args = args)
[01:28:35.127]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:35.127]             }
[01:28:35.127]             else {
[01:28:35.127]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:35.127]             }
[01:28:35.127]             {
[01:28:35.127]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:35.127]                   0L) {
[01:28:35.127]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:35.127]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:35.127]                   base::options(opts)
[01:28:35.127]                 }
[01:28:35.127]                 {
[01:28:35.127]                   {
[01:28:35.127]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:35.127]                     NULL
[01:28:35.127]                   }
[01:28:35.127]                   options(future.plan = NULL)
[01:28:35.127]                   if (is.na(NA_character_)) 
[01:28:35.127]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:35.127]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:35.127]                   future::plan(list(a = function (..., workers = availableCores(), 
[01:28:35.127]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.127]                     envir = parent.frame()) 
[01:28:35.127]                   {
[01:28:35.127]                     if (is.function(workers)) 
[01:28:35.127]                       workers <- workers()
[01:28:35.127]                     workers <- structure(as.integer(workers), 
[01:28:35.127]                       class = class(workers))
[01:28:35.127]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.127]                       workers >= 1)
[01:28:35.127]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.127]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.127]                     }
[01:28:35.127]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.127]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.127]                       envir = envir)
[01:28:35.127]                     if (!future$lazy) 
[01:28:35.127]                       future <- run(future)
[01:28:35.127]                     invisible(future)
[01:28:35.127]                   }, b = function (..., workers = availableCores(), 
[01:28:35.127]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.127]                     envir = parent.frame()) 
[01:28:35.127]                   {
[01:28:35.127]                     if (is.function(workers)) 
[01:28:35.127]                       workers <- workers()
[01:28:35.127]                     workers <- structure(as.integer(workers), 
[01:28:35.127]                       class = class(workers))
[01:28:35.127]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.127]                       workers >= 1)
[01:28:35.127]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.127]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.127]                     }
[01:28:35.127]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.127]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.127]                       envir = envir)
[01:28:35.127]                     if (!future$lazy) 
[01:28:35.127]                       future <- run(future)
[01:28:35.127]                     invisible(future)
[01:28:35.127]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:35.127]                 }
[01:28:35.127]             }
[01:28:35.127]         }
[01:28:35.127]     })
[01:28:35.127]     if (TRUE) {
[01:28:35.127]         base::sink(type = "output", split = FALSE)
[01:28:35.127]         if (TRUE) {
[01:28:35.127]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:35.127]         }
[01:28:35.127]         else {
[01:28:35.127]             ...future.result["stdout"] <- base::list(NULL)
[01:28:35.127]         }
[01:28:35.127]         base::close(...future.stdout)
[01:28:35.127]         ...future.stdout <- NULL
[01:28:35.127]     }
[01:28:35.127]     ...future.result$conditions <- ...future.conditions
[01:28:35.127]     ...future.result$finished <- base::Sys.time()
[01:28:35.127]     ...future.result
[01:28:35.127] }
[01:28:35.218] MultisessionFuture started
[01:28:35.218] result() for ClusterFuture ...
[01:28:35.219] receiveMessageFromWorker() for ClusterFuture ...
[01:28:35.219] - Validating connection of MultisessionFuture
[01:28:35.322] - received message: FutureResult
[01:28:35.323] - Received FutureResult
[01:28:35.323] - Erased future from FutureRegistry
[01:28:35.323] result() for ClusterFuture ...
[01:28:35.323] - result already collected: FutureResult
[01:28:35.324] result() for ClusterFuture ... done
[01:28:35.324] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:35.324] result() for ClusterFuture ... done
[01:28:35.324] result() for ClusterFuture ...
[01:28:35.324] - result already collected: FutureResult
[01:28:35.325] result() for ClusterFuture ... done
[01:28:35.325] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:35.328] plan(): nbrOfWorkers() = 2
[01:28:35.328] getGlobalsAndPackages() ...
[01:28:35.328] Searching for globals...
[01:28:35.349] - globals found: [21] '{', '<-', 'unclass', '::', '[', 'nested', '-', 'stopifnot', '==', 'length', 'inherits', '[[', 'strategy2', 'for', 'seq_along', 'attr', 'attr<-', '[[<-', 'all.equal', 'list', '%<-%'
[01:28:35.350] Searching for globals ... DONE
[01:28:35.350] Resolving globals: FALSE
[01:28:35.351] The total size of the 2 globals is 88.27 KiB (90384 bytes)
[01:28:35.352] 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 88.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'nested' (88.15 KiB of class 'list') and 'strategy2' (120 bytes of class 'character')
[01:28:35.352] - globals: [2] 'nested', 'strategy2'
[01:28:35.352] - packages: [1] 'future'
[01:28:35.353] getGlobalsAndPackages() ... DONE
[01:28:35.353] run() for 'Future' ...
[01:28:35.353] - state: 'created'
[01:28:35.353] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:35.368] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:35.368] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:35.368]   - Field: 'node'
[01:28:35.369]   - Field: 'label'
[01:28:35.369]   - Field: 'local'
[01:28:35.369]   - Field: 'owner'
[01:28:35.369]   - Field: 'envir'
[01:28:35.369]   - Field: 'workers'
[01:28:35.370]   - Field: 'packages'
[01:28:35.370]   - Field: 'gc'
[01:28:35.370]   - Field: 'conditions'
[01:28:35.370]   - Field: 'persistent'
[01:28:35.370]   - Field: 'expr'
[01:28:35.370]   - Field: 'uuid'
[01:28:35.371]   - Field: 'seed'
[01:28:35.371]   - Field: 'version'
[01:28:35.371]   - Field: 'result'
[01:28:35.371]   - Field: 'asynchronous'
[01:28:35.371]   - Field: 'calls'
[01:28:35.371]   - Field: 'globals'
[01:28:35.372]   - Field: 'stdout'
[01:28:35.372]   - Field: 'earlySignal'
[01:28:35.372]   - Field: 'lazy'
[01:28:35.372]   - Field: 'state'
[01:28:35.372] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:35.373] - Launch lazy future ...
[01:28:35.373] Packages needed by the future expression (n = 1): 'future'
[01:28:35.373] Packages needed by future strategies (n = 1): 'future'
[01:28:35.374] {
[01:28:35.374]     {
[01:28:35.374]         {
[01:28:35.374]             ...future.startTime <- base::Sys.time()
[01:28:35.374]             {
[01:28:35.374]                 {
[01:28:35.374]                   {
[01:28:35.374]                     {
[01:28:35.374]                       {
[01:28:35.374]                         base::local({
[01:28:35.374]                           has_future <- base::requireNamespace("future", 
[01:28:35.374]                             quietly = TRUE)
[01:28:35.374]                           if (has_future) {
[01:28:35.374]                             ns <- base::getNamespace("future")
[01:28:35.374]                             version <- ns[[".package"]][["version"]]
[01:28:35.374]                             if (is.null(version)) 
[01:28:35.374]                               version <- utils::packageVersion("future")
[01:28:35.374]                           }
[01:28:35.374]                           else {
[01:28:35.374]                             version <- NULL
[01:28:35.374]                           }
[01:28:35.374]                           if (!has_future || version < "1.8.0") {
[01:28:35.374]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:35.374]                               "", base::R.version$version.string), 
[01:28:35.374]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:35.374]                                 base::R.version$platform, 8 * 
[01:28:35.374]                                   base::.Machine$sizeof.pointer), 
[01:28:35.374]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:35.374]                                 "release", "version")], collapse = " "), 
[01:28:35.374]                               hostname = base::Sys.info()[["nodename"]])
[01:28:35.374]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:35.374]                               info)
[01:28:35.374]                             info <- base::paste(info, collapse = "; ")
[01:28:35.374]                             if (!has_future) {
[01:28:35.374]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:35.374]                                 info)
[01:28:35.374]                             }
[01:28:35.374]                             else {
[01:28:35.374]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:35.374]                                 info, version)
[01:28:35.374]                             }
[01:28:35.374]                             base::stop(msg)
[01:28:35.374]                           }
[01:28:35.374]                         })
[01:28:35.374]                       }
[01:28:35.374]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:35.374]                       base::options(mc.cores = 1L)
[01:28:35.374]                     }
[01:28:35.374]                     base::local({
[01:28:35.374]                       for (pkg in "future") {
[01:28:35.374]                         base::loadNamespace(pkg)
[01:28:35.374]                         base::library(pkg, character.only = TRUE)
[01:28:35.374]                       }
[01:28:35.374]                     })
[01:28:35.374]                   }
[01:28:35.374]                   options(future.plan = NULL)
[01:28:35.374]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:35.374]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:35.374]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.374]                     envir = parent.frame()) 
[01:28:35.374]                   {
[01:28:35.374]                     if (is.function(workers)) 
[01:28:35.374]                       workers <- workers()
[01:28:35.374]                     workers <- structure(as.integer(workers), 
[01:28:35.374]                       class = class(workers))
[01:28:35.374]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.374]                       workers >= 1)
[01:28:35.374]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.374]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.374]                     }
[01:28:35.374]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.374]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.374]                       envir = envir)
[01:28:35.374]                     if (!future$lazy) 
[01:28:35.374]                       future <- run(future)
[01:28:35.374]                     invisible(future)
[01:28:35.374]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:35.374]                 }
[01:28:35.374]                 ...future.workdir <- getwd()
[01:28:35.374]             }
[01:28:35.374]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:35.374]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:35.374]         }
[01:28:35.374]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:35.374]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:35.374]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:35.374]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:35.374]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:35.374]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:35.374]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:35.374]             base::names(...future.oldOptions))
[01:28:35.374]     }
[01:28:35.374]     if (FALSE) {
[01:28:35.374]     }
[01:28:35.374]     else {
[01:28:35.374]         if (TRUE) {
[01:28:35.374]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:35.374]                 open = "w")
[01:28:35.374]         }
[01:28:35.374]         else {
[01:28:35.374]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:35.374]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:35.374]         }
[01:28:35.374]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:35.374]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:35.374]             base::sink(type = "output", split = FALSE)
[01:28:35.374]             base::close(...future.stdout)
[01:28:35.374]         }, add = TRUE)
[01:28:35.374]     }
[01:28:35.374]     ...future.frame <- base::sys.nframe()
[01:28:35.374]     ...future.conditions <- base::list()
[01:28:35.374]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:35.374]     if (FALSE) {
[01:28:35.374]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:35.374]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:35.374]     }
[01:28:35.374]     ...future.result <- base::tryCatch({
[01:28:35.374]         base::withCallingHandlers({
[01:28:35.374]             ...future.value <- base::withVisible(base::local({
[01:28:35.374]                 ...future.makeSendCondition <- base::local({
[01:28:35.374]                   sendCondition <- NULL
[01:28:35.374]                   function(frame = 1L) {
[01:28:35.374]                     if (is.function(sendCondition)) 
[01:28:35.374]                       return(sendCondition)
[01:28:35.374]                     ns <- getNamespace("parallel")
[01:28:35.374]                     if (exists("sendData", mode = "function", 
[01:28:35.374]                       envir = ns)) {
[01:28:35.374]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:35.374]                         envir = ns)
[01:28:35.374]                       envir <- sys.frame(frame)
[01:28:35.374]                       master <- NULL
[01:28:35.374]                       while (!identical(envir, .GlobalEnv) && 
[01:28:35.374]                         !identical(envir, emptyenv())) {
[01:28:35.374]                         if (exists("master", mode = "list", envir = envir, 
[01:28:35.374]                           inherits = FALSE)) {
[01:28:35.374]                           master <- get("master", mode = "list", 
[01:28:35.374]                             envir = envir, inherits = FALSE)
[01:28:35.374]                           if (inherits(master, c("SOCKnode", 
[01:28:35.374]                             "SOCK0node"))) {
[01:28:35.374]                             sendCondition <<- function(cond) {
[01:28:35.374]                               data <- list(type = "VALUE", value = cond, 
[01:28:35.374]                                 success = TRUE)
[01:28:35.374]                               parallel_sendData(master, data)
[01:28:35.374]                             }
[01:28:35.374]                             return(sendCondition)
[01:28:35.374]                           }
[01:28:35.374]                         }
[01:28:35.374]                         frame <- frame + 1L
[01:28:35.374]                         envir <- sys.frame(frame)
[01:28:35.374]                       }
[01:28:35.374]                     }
[01:28:35.374]                     sendCondition <<- function(cond) NULL
[01:28:35.374]                   }
[01:28:35.374]                 })
[01:28:35.374]                 withCallingHandlers({
[01:28:35.374]                   {
[01:28:35.374]                     a <- 1L
[01:28:35.374]                     plan_a <- unclass(future::plan("list"))
[01:28:35.374]                     nested_a <- nested[-1]
[01:28:35.374]                     stopifnot(length(nested_a) == 1L, length(plan_a) == 
[01:28:35.374]                       1L, inherits(plan_a[[1]], "future"), inherits(future::plan("next"), 
[01:28:35.374]                       strategy2))
[01:28:35.374]                     for (kk in seq_along(plan_a)) attr(plan_a[[kk]], 
[01:28:35.374]                       "init") <- NULL
[01:28:35.374]                     for (kk in seq_along(nested_a)) attr(nested_a[[kk]], 
[01:28:35.374]                       "init") <- NULL
[01:28:35.374]                     stopifnot(all.equal(plan_a, nested_a))
[01:28:35.374]                     y %<-% {
[01:28:35.374]                       b <- 2L
[01:28:35.374]                       plan_b <- future::plan("list")
[01:28:35.374]                       nested_b <- nested_a[-1]
[01:28:35.374]                       stopifnot(length(nested_b) == 0L, length(plan_b) == 
[01:28:35.374]                         1L, inherits(plan_b[[1]], "future"), 
[01:28:35.374]                         inherits(future::plan("next"), "sequential"))
[01:28:35.374]                       list(a = a, nested_a = nested_a, plan_a = plan_a, 
[01:28:35.374]                         b = b, nested_b = nested_b, plan_b = plan_b)
[01:28:35.374]                     }
[01:28:35.374]                     y
[01:28:35.374]                   }
[01:28:35.374]                 }, immediateCondition = function(cond) {
[01:28:35.374]                   sendCondition <- ...future.makeSendCondition()
[01:28:35.374]                   sendCondition(cond)
[01:28:35.374]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.374]                   {
[01:28:35.374]                     inherits <- base::inherits
[01:28:35.374]                     invokeRestart <- base::invokeRestart
[01:28:35.374]                     is.null <- base::is.null
[01:28:35.374]                     muffled <- FALSE
[01:28:35.374]                     if (inherits(cond, "message")) {
[01:28:35.374]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:35.374]                       if (muffled) 
[01:28:35.374]                         invokeRestart("muffleMessage")
[01:28:35.374]                     }
[01:28:35.374]                     else if (inherits(cond, "warning")) {
[01:28:35.374]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:35.374]                       if (muffled) 
[01:28:35.374]                         invokeRestart("muffleWarning")
[01:28:35.374]                     }
[01:28:35.374]                     else if (inherits(cond, "condition")) {
[01:28:35.374]                       if (!is.null(pattern)) {
[01:28:35.374]                         computeRestarts <- base::computeRestarts
[01:28:35.374]                         grepl <- base::grepl
[01:28:35.374]                         restarts <- computeRestarts(cond)
[01:28:35.374]                         for (restart in restarts) {
[01:28:35.374]                           name <- restart$name
[01:28:35.374]                           if (is.null(name)) 
[01:28:35.374]                             next
[01:28:35.374]                           if (!grepl(pattern, name)) 
[01:28:35.374]                             next
[01:28:35.374]                           invokeRestart(restart)
[01:28:35.374]                           muffled <- TRUE
[01:28:35.374]                           break
[01:28:35.374]                         }
[01:28:35.374]                       }
[01:28:35.374]                     }
[01:28:35.374]                     invisible(muffled)
[01:28:35.374]                   }
[01:28:35.374]                   muffleCondition(cond)
[01:28:35.374]                 })
[01:28:35.374]             }))
[01:28:35.374]             future::FutureResult(value = ...future.value$value, 
[01:28:35.374]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:35.374]                   ...future.rng), globalenv = if (FALSE) 
[01:28:35.374]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:35.374]                     ...future.globalenv.names))
[01:28:35.374]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:35.374]         }, condition = base::local({
[01:28:35.374]             c <- base::c
[01:28:35.374]             inherits <- base::inherits
[01:28:35.374]             invokeRestart <- base::invokeRestart
[01:28:35.374]             length <- base::length
[01:28:35.374]             list <- base::list
[01:28:35.374]             seq.int <- base::seq.int
[01:28:35.374]             signalCondition <- base::signalCondition
[01:28:35.374]             sys.calls <- base::sys.calls
[01:28:35.374]             `[[` <- base::`[[`
[01:28:35.374]             `+` <- base::`+`
[01:28:35.374]             `<<-` <- base::`<<-`
[01:28:35.374]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:35.374]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:35.374]                   3L)]
[01:28:35.374]             }
[01:28:35.374]             function(cond) {
[01:28:35.374]                 is_error <- inherits(cond, "error")
[01:28:35.374]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:35.374]                   NULL)
[01:28:35.374]                 if (is_error) {
[01:28:35.374]                   sessionInformation <- function() {
[01:28:35.374]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:35.374]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:35.374]                       search = base::search(), system = base::Sys.info())
[01:28:35.374]                   }
[01:28:35.374]                   ...future.conditions[[length(...future.conditions) + 
[01:28:35.374]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:35.374]                     cond$call), session = sessionInformation(), 
[01:28:35.374]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:35.374]                   signalCondition(cond)
[01:28:35.374]                 }
[01:28:35.374]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:35.374]                 "immediateCondition"))) {
[01:28:35.374]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:35.374]                   ...future.conditions[[length(...future.conditions) + 
[01:28:35.374]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:35.374]                   if (TRUE && !signal) {
[01:28:35.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.374]                     {
[01:28:35.374]                       inherits <- base::inherits
[01:28:35.374]                       invokeRestart <- base::invokeRestart
[01:28:35.374]                       is.null <- base::is.null
[01:28:35.374]                       muffled <- FALSE
[01:28:35.374]                       if (inherits(cond, "message")) {
[01:28:35.374]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:35.374]                         if (muffled) 
[01:28:35.374]                           invokeRestart("muffleMessage")
[01:28:35.374]                       }
[01:28:35.374]                       else if (inherits(cond, "warning")) {
[01:28:35.374]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:35.374]                         if (muffled) 
[01:28:35.374]                           invokeRestart("muffleWarning")
[01:28:35.374]                       }
[01:28:35.374]                       else if (inherits(cond, "condition")) {
[01:28:35.374]                         if (!is.null(pattern)) {
[01:28:35.374]                           computeRestarts <- base::computeRestarts
[01:28:35.374]                           grepl <- base::grepl
[01:28:35.374]                           restarts <- computeRestarts(cond)
[01:28:35.374]                           for (restart in restarts) {
[01:28:35.374]                             name <- restart$name
[01:28:35.374]                             if (is.null(name)) 
[01:28:35.374]                               next
[01:28:35.374]                             if (!grepl(pattern, name)) 
[01:28:35.374]                               next
[01:28:35.374]                             invokeRestart(restart)
[01:28:35.374]                             muffled <- TRUE
[01:28:35.374]                             break
[01:28:35.374]                           }
[01:28:35.374]                         }
[01:28:35.374]                       }
[01:28:35.374]                       invisible(muffled)
[01:28:35.374]                     }
[01:28:35.374]                     muffleCondition(cond, pattern = "^muffle")
[01:28:35.374]                   }
[01:28:35.374]                 }
[01:28:35.374]                 else {
[01:28:35.374]                   if (TRUE) {
[01:28:35.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.374]                     {
[01:28:35.374]                       inherits <- base::inherits
[01:28:35.374]                       invokeRestart <- base::invokeRestart
[01:28:35.374]                       is.null <- base::is.null
[01:28:35.374]                       muffled <- FALSE
[01:28:35.374]                       if (inherits(cond, "message")) {
[01:28:35.374]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:35.374]                         if (muffled) 
[01:28:35.374]                           invokeRestart("muffleMessage")
[01:28:35.374]                       }
[01:28:35.374]                       else if (inherits(cond, "warning")) {
[01:28:35.374]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:35.374]                         if (muffled) 
[01:28:35.374]                           invokeRestart("muffleWarning")
[01:28:35.374]                       }
[01:28:35.374]                       else if (inherits(cond, "condition")) {
[01:28:35.374]                         if (!is.null(pattern)) {
[01:28:35.374]                           computeRestarts <- base::computeRestarts
[01:28:35.374]                           grepl <- base::grepl
[01:28:35.374]                           restarts <- computeRestarts(cond)
[01:28:35.374]                           for (restart in restarts) {
[01:28:35.374]                             name <- restart$name
[01:28:35.374]                             if (is.null(name)) 
[01:28:35.374]                               next
[01:28:35.374]                             if (!grepl(pattern, name)) 
[01:28:35.374]                               next
[01:28:35.374]                             invokeRestart(restart)
[01:28:35.374]                             muffled <- TRUE
[01:28:35.374]                             break
[01:28:35.374]                           }
[01:28:35.374]                         }
[01:28:35.374]                       }
[01:28:35.374]                       invisible(muffled)
[01:28:35.374]                     }
[01:28:35.374]                     muffleCondition(cond, pattern = "^muffle")
[01:28:35.374]                   }
[01:28:35.374]                 }
[01:28:35.374]             }
[01:28:35.374]         }))
[01:28:35.374]     }, error = function(ex) {
[01:28:35.374]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:35.374]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:35.374]                 ...future.rng), started = ...future.startTime, 
[01:28:35.374]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:35.374]             version = "1.8"), class = "FutureResult")
[01:28:35.374]     }, finally = {
[01:28:35.374]         if (!identical(...future.workdir, getwd())) 
[01:28:35.374]             setwd(...future.workdir)
[01:28:35.374]         {
[01:28:35.374]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:35.374]                 ...future.oldOptions$nwarnings <- NULL
[01:28:35.374]             }
[01:28:35.374]             base::options(...future.oldOptions)
[01:28:35.374]             if (.Platform$OS.type == "windows") {
[01:28:35.374]                 old_names <- names(...future.oldEnvVars)
[01:28:35.374]                 envs <- base::Sys.getenv()
[01:28:35.374]                 names <- names(envs)
[01:28:35.374]                 common <- intersect(names, old_names)
[01:28:35.374]                 added <- setdiff(names, old_names)
[01:28:35.374]                 removed <- setdiff(old_names, names)
[01:28:35.374]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:35.374]                   envs[common]]
[01:28:35.374]                 NAMES <- toupper(changed)
[01:28:35.374]                 args <- list()
[01:28:35.374]                 for (kk in seq_along(NAMES)) {
[01:28:35.374]                   name <- changed[[kk]]
[01:28:35.374]                   NAME <- NAMES[[kk]]
[01:28:35.374]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.374]                     next
[01:28:35.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:35.374]                 }
[01:28:35.374]                 NAMES <- toupper(added)
[01:28:35.374]                 for (kk in seq_along(NAMES)) {
[01:28:35.374]                   name <- added[[kk]]
[01:28:35.374]                   NAME <- NAMES[[kk]]
[01:28:35.374]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.374]                     next
[01:28:35.374]                   args[[name]] <- ""
[01:28:35.374]                 }
[01:28:35.374]                 NAMES <- toupper(removed)
[01:28:35.374]                 for (kk in seq_along(NAMES)) {
[01:28:35.374]                   name <- removed[[kk]]
[01:28:35.374]                   NAME <- NAMES[[kk]]
[01:28:35.374]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.374]                     next
[01:28:35.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:35.374]                 }
[01:28:35.374]                 if (length(args) > 0) 
[01:28:35.374]                   base::do.call(base::Sys.setenv, args = args)
[01:28:35.374]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:35.374]             }
[01:28:35.374]             else {
[01:28:35.374]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:35.374]             }
[01:28:35.374]             {
[01:28:35.374]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:35.374]                   0L) {
[01:28:35.374]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:35.374]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:35.374]                   base::options(opts)
[01:28:35.374]                 }
[01:28:35.374]                 {
[01:28:35.374]                   {
[01:28:35.374]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:35.374]                     NULL
[01:28:35.374]                   }
[01:28:35.374]                   options(future.plan = NULL)
[01:28:35.374]                   if (is.na(NA_character_)) 
[01:28:35.374]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:35.374]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:35.374]                   future::plan(list(a = function (..., workers = availableCores(), 
[01:28:35.374]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.374]                     envir = parent.frame()) 
[01:28:35.374]                   {
[01:28:35.374]                     if (is.function(workers)) 
[01:28:35.374]                       workers <- workers()
[01:28:35.374]                     workers <- structure(as.integer(workers), 
[01:28:35.374]                       class = class(workers))
[01:28:35.374]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.374]                       workers >= 1)
[01:28:35.374]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.374]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.374]                     }
[01:28:35.374]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.374]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.374]                       envir = envir)
[01:28:35.374]                     if (!future$lazy) 
[01:28:35.374]                       future <- run(future)
[01:28:35.374]                     invisible(future)
[01:28:35.374]                   }, b = function (..., workers = availableCores(), 
[01:28:35.374]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.374]                     envir = parent.frame()) 
[01:28:35.374]                   {
[01:28:35.374]                     if (is.function(workers)) 
[01:28:35.374]                       workers <- workers()
[01:28:35.374]                     workers <- structure(as.integer(workers), 
[01:28:35.374]                       class = class(workers))
[01:28:35.374]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.374]                       workers >= 1)
[01:28:35.374]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.374]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.374]                     }
[01:28:35.374]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.374]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.374]                       envir = envir)
[01:28:35.374]                     if (!future$lazy) 
[01:28:35.374]                       future <- run(future)
[01:28:35.374]                     invisible(future)
[01:28:35.374]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:35.374]                 }
[01:28:35.374]             }
[01:28:35.374]         }
[01:28:35.374]     })
[01:28:35.374]     if (TRUE) {
[01:28:35.374]         base::sink(type = "output", split = FALSE)
[01:28:35.374]         if (TRUE) {
[01:28:35.374]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:35.374]         }
[01:28:35.374]         else {
[01:28:35.374]             ...future.result["stdout"] <- base::list(NULL)
[01:28:35.374]         }
[01:28:35.374]         base::close(...future.stdout)
[01:28:35.374]         ...future.stdout <- NULL
[01:28:35.374]     }
[01:28:35.374]     ...future.result$conditions <- ...future.conditions
[01:28:35.374]     ...future.result$finished <- base::Sys.time()
[01:28:35.374]     ...future.result
[01:28:35.374] }
[01:28:35.380] Exporting 2 global objects (88.27 KiB) to cluster node #1 ...
[01:28:35.381] Exporting 'nested' (88.15 KiB) to cluster node #1 ...
[01:28:35.381] Exporting 'nested' (88.15 KiB) to cluster node #1 ... DONE
[01:28:35.382] Exporting 'strategy2' (120 bytes) to cluster node #1 ...
[01:28:35.382] Exporting 'strategy2' (120 bytes) to cluster node #1 ... DONE
[01:28:35.382] Exporting 2 global objects (88.27 KiB) to cluster node #1 ... DONE
[01:28:35.383] MultisessionFuture started
[01:28:35.383] - Launch lazy future ... done
[01:28:35.383] run() for 'MultisessionFuture' ... done
[01:28:35.384] result() for ClusterFuture ...
[01:28:35.384] receiveMessageFromWorker() for ClusterFuture ...
[01:28:35.384] - Validating connection of MultisessionFuture
[01:28:35.459] - received message: FutureResult
[01:28:35.460] - Received FutureResult
[01:28:35.460] - Erased future from FutureRegistry
[01:28:35.460] result() for ClusterFuture ...
[01:28:35.460] - result already collected: FutureResult
[01:28:35.460] result() for ClusterFuture ... done
[01:28:35.461] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:35.461] result() for ClusterFuture ... done
[01:28:35.461] result() for ClusterFuture ...
[01:28:35.461] - result already collected: FutureResult
[01:28:35.461] 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(*, "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(*, "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"
[01:28:35.470] getGlobalsAndPackages() ...
[01:28:35.471] Searching for globals...
[01:28:35.473] - globals found: [7] '{', 'value', 'future', 'subset', 'data', '==', 'a'
[01:28:35.473] Searching for globals ... DONE
[01:28:35.473] Resolving globals: FALSE
[01:28:35.474] The total size of the 1 globals is 128 bytes (128 bytes)
[01:28:35.477] The total size of the 1 globals exported for future expression ('{; value(future(subset(data, a == 2))); }') is 128 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'data' (128 bytes of class 'list')
[01:28:35.477] - globals: [1] 'data'
[01:28:35.477] - packages: [1] 'future'
[01:28:35.477] getGlobalsAndPackages() ... DONE
[01:28:35.478] run() for 'Future' ...
[01:28:35.478] - state: 'created'
[01:28:35.478] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:35.493] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:35.494] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:35.494]   - Field: 'node'
[01:28:35.494]   - Field: 'label'
[01:28:35.494]   - Field: 'local'
[01:28:35.494]   - Field: 'owner'
[01:28:35.495]   - Field: 'envir'
[01:28:35.495]   - Field: 'workers'
[01:28:35.495]   - Field: 'packages'
[01:28:35.495]   - Field: 'gc'
[01:28:35.495]   - Field: 'conditions'
[01:28:35.495]   - Field: 'persistent'
[01:28:35.496]   - Field: 'expr'
[01:28:35.496]   - Field: 'uuid'
[01:28:35.496]   - Field: 'seed'
[01:28:35.496]   - Field: 'version'
[01:28:35.496]   - Field: 'result'
[01:28:35.496]   - Field: 'asynchronous'
[01:28:35.497]   - Field: 'calls'
[01:28:35.497]   - Field: 'globals'
[01:28:35.497]   - Field: 'stdout'
[01:28:35.497]   - Field: 'earlySignal'
[01:28:35.497]   - Field: 'lazy'
[01:28:35.498]   - Field: 'state'
[01:28:35.498] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:35.498] - Launch lazy future ...
[01:28:35.498] Packages needed by the future expression (n = 1): 'future'
[01:28:35.499] Packages needed by future strategies (n = 1): 'future'
[01:28:35.499] {
[01:28:35.499]     {
[01:28:35.499]         {
[01:28:35.499]             ...future.startTime <- base::Sys.time()
[01:28:35.499]             {
[01:28:35.499]                 {
[01:28:35.499]                   {
[01:28:35.499]                     {
[01:28:35.499]                       {
[01:28:35.499]                         base::local({
[01:28:35.499]                           has_future <- base::requireNamespace("future", 
[01:28:35.499]                             quietly = TRUE)
[01:28:35.499]                           if (has_future) {
[01:28:35.499]                             ns <- base::getNamespace("future")
[01:28:35.499]                             version <- ns[[".package"]][["version"]]
[01:28:35.499]                             if (is.null(version)) 
[01:28:35.499]                               version <- utils::packageVersion("future")
[01:28:35.499]                           }
[01:28:35.499]                           else {
[01:28:35.499]                             version <- NULL
[01:28:35.499]                           }
[01:28:35.499]                           if (!has_future || version < "1.8.0") {
[01:28:35.499]                             info <- base::c(r_version = base::gsub("R version ", 
[01:28:35.499]                               "", base::R.version$version.string), 
[01:28:35.499]                               platform = base::sprintf("%s (%s-bit)", 
[01:28:35.499]                                 base::R.version$platform, 8 * 
[01:28:35.499]                                   base::.Machine$sizeof.pointer), 
[01:28:35.499]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:35.499]                                 "release", "version")], collapse = " "), 
[01:28:35.499]                               hostname = base::Sys.info()[["nodename"]])
[01:28:35.499]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:28:35.499]                               info)
[01:28:35.499]                             info <- base::paste(info, collapse = "; ")
[01:28:35.499]                             if (!has_future) {
[01:28:35.499]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:35.499]                                 info)
[01:28:35.499]                             }
[01:28:35.499]                             else {
[01:28:35.499]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:35.499]                                 info, version)
[01:28:35.499]                             }
[01:28:35.499]                             base::stop(msg)
[01:28:35.499]                           }
[01:28:35.499]                         })
[01:28:35.499]                       }
[01:28:35.499]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:35.499]                       base::options(mc.cores = 1L)
[01:28:35.499]                     }
[01:28:35.499]                     base::local({
[01:28:35.499]                       for (pkg in "future") {
[01:28:35.499]                         base::loadNamespace(pkg)
[01:28:35.499]                         base::library(pkg, character.only = TRUE)
[01:28:35.499]                       }
[01:28:35.499]                     })
[01:28:35.499]                   }
[01:28:35.499]                   options(future.plan = NULL)
[01:28:35.499]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:35.499]                   future::plan(list(b = function (..., workers = availableCores(), 
[01:28:35.499]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.499]                     envir = parent.frame()) 
[01:28:35.499]                   {
[01:28:35.499]                     if (is.function(workers)) 
[01:28:35.499]                       workers <- workers()
[01:28:35.499]                     workers <- structure(as.integer(workers), 
[01:28:35.499]                       class = class(workers))
[01:28:35.499]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.499]                       workers >= 1)
[01:28:35.499]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.499]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.499]                     }
[01:28:35.499]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.499]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.499]                       envir = envir)
[01:28:35.499]                     if (!future$lazy) 
[01:28:35.499]                       future <- run(future)
[01:28:35.499]                     invisible(future)
[01:28:35.499]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:35.499]                 }
[01:28:35.499]                 ...future.workdir <- getwd()
[01:28:35.499]             }
[01:28:35.499]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:35.499]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:35.499]         }
[01:28:35.499]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:35.499]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:35.499]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:35.499]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:35.499]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:35.499]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:35.499]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:35.499]             base::names(...future.oldOptions))
[01:28:35.499]     }
[01:28:35.499]     if (FALSE) {
[01:28:35.499]     }
[01:28:35.499]     else {
[01:28:35.499]         if (TRUE) {
[01:28:35.499]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:35.499]                 open = "w")
[01:28:35.499]         }
[01:28:35.499]         else {
[01:28:35.499]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:35.499]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:35.499]         }
[01:28:35.499]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:35.499]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:35.499]             base::sink(type = "output", split = FALSE)
[01:28:35.499]             base::close(...future.stdout)
[01:28:35.499]         }, add = TRUE)
[01:28:35.499]     }
[01:28:35.499]     ...future.frame <- base::sys.nframe()
[01:28:35.499]     ...future.conditions <- base::list()
[01:28:35.499]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:35.499]     if (FALSE) {
[01:28:35.499]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:35.499]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:35.499]     }
[01:28:35.499]     ...future.result <- base::tryCatch({
[01:28:35.499]         base::withCallingHandlers({
[01:28:35.499]             ...future.value <- base::withVisible(base::local({
[01:28:35.499]                 ...future.makeSendCondition <- base::local({
[01:28:35.499]                   sendCondition <- NULL
[01:28:35.499]                   function(frame = 1L) {
[01:28:35.499]                     if (is.function(sendCondition)) 
[01:28:35.499]                       return(sendCondition)
[01:28:35.499]                     ns <- getNamespace("parallel")
[01:28:35.499]                     if (exists("sendData", mode = "function", 
[01:28:35.499]                       envir = ns)) {
[01:28:35.499]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:35.499]                         envir = ns)
[01:28:35.499]                       envir <- sys.frame(frame)
[01:28:35.499]                       master <- NULL
[01:28:35.499]                       while (!identical(envir, .GlobalEnv) && 
[01:28:35.499]                         !identical(envir, emptyenv())) {
[01:28:35.499]                         if (exists("master", mode = "list", envir = envir, 
[01:28:35.499]                           inherits = FALSE)) {
[01:28:35.499]                           master <- get("master", mode = "list", 
[01:28:35.499]                             envir = envir, inherits = FALSE)
[01:28:35.499]                           if (inherits(master, c("SOCKnode", 
[01:28:35.499]                             "SOCK0node"))) {
[01:28:35.499]                             sendCondition <<- function(cond) {
[01:28:35.499]                               data <- list(type = "VALUE", value = cond, 
[01:28:35.499]                                 success = TRUE)
[01:28:35.499]                               parallel_sendData(master, data)
[01:28:35.499]                             }
[01:28:35.499]                             return(sendCondition)
[01:28:35.499]                           }
[01:28:35.499]                         }
[01:28:35.499]                         frame <- frame + 1L
[01:28:35.499]                         envir <- sys.frame(frame)
[01:28:35.499]                       }
[01:28:35.499]                     }
[01:28:35.499]                     sendCondition <<- function(cond) NULL
[01:28:35.499]                   }
[01:28:35.499]                 })
[01:28:35.499]                 withCallingHandlers({
[01:28:35.499]                   {
[01:28:35.499]                     value(future(subset(data, a == 2)))
[01:28:35.499]                   }
[01:28:35.499]                 }, immediateCondition = function(cond) {
[01:28:35.499]                   sendCondition <- ...future.makeSendCondition()
[01:28:35.499]                   sendCondition(cond)
[01:28:35.499]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.499]                   {
[01:28:35.499]                     inherits <- base::inherits
[01:28:35.499]                     invokeRestart <- base::invokeRestart
[01:28:35.499]                     is.null <- base::is.null
[01:28:35.499]                     muffled <- FALSE
[01:28:35.499]                     if (inherits(cond, "message")) {
[01:28:35.499]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:35.499]                       if (muffled) 
[01:28:35.499]                         invokeRestart("muffleMessage")
[01:28:35.499]                     }
[01:28:35.499]                     else if (inherits(cond, "warning")) {
[01:28:35.499]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:35.499]                       if (muffled) 
[01:28:35.499]                         invokeRestart("muffleWarning")
[01:28:35.499]                     }
[01:28:35.499]                     else if (inherits(cond, "condition")) {
[01:28:35.499]                       if (!is.null(pattern)) {
[01:28:35.499]                         computeRestarts <- base::computeRestarts
[01:28:35.499]                         grepl <- base::grepl
[01:28:35.499]                         restarts <- computeRestarts(cond)
[01:28:35.499]                         for (restart in restarts) {
[01:28:35.499]                           name <- restart$name
[01:28:35.499]                           if (is.null(name)) 
[01:28:35.499]                             next
[01:28:35.499]                           if (!grepl(pattern, name)) 
[01:28:35.499]                             next
[01:28:35.499]                           invokeRestart(restart)
[01:28:35.499]                           muffled <- TRUE
[01:28:35.499]                           break
[01:28:35.499]                         }
[01:28:35.499]                       }
[01:28:35.499]                     }
[01:28:35.499]                     invisible(muffled)
[01:28:35.499]                   }
[01:28:35.499]                   muffleCondition(cond)
[01:28:35.499]                 })
[01:28:35.499]             }))
[01:28:35.499]             future::FutureResult(value = ...future.value$value, 
[01:28:35.499]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:35.499]                   ...future.rng), globalenv = if (FALSE) 
[01:28:35.499]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:35.499]                     ...future.globalenv.names))
[01:28:35.499]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:35.499]         }, condition = base::local({
[01:28:35.499]             c <- base::c
[01:28:35.499]             inherits <- base::inherits
[01:28:35.499]             invokeRestart <- base::invokeRestart
[01:28:35.499]             length <- base::length
[01:28:35.499]             list <- base::list
[01:28:35.499]             seq.int <- base::seq.int
[01:28:35.499]             signalCondition <- base::signalCondition
[01:28:35.499]             sys.calls <- base::sys.calls
[01:28:35.499]             `[[` <- base::`[[`
[01:28:35.499]             `+` <- base::`+`
[01:28:35.499]             `<<-` <- base::`<<-`
[01:28:35.499]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:35.499]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:35.499]                   3L)]
[01:28:35.499]             }
[01:28:35.499]             function(cond) {
[01:28:35.499]                 is_error <- inherits(cond, "error")
[01:28:35.499]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:35.499]                   NULL)
[01:28:35.499]                 if (is_error) {
[01:28:35.499]                   sessionInformation <- function() {
[01:28:35.499]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:35.499]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:35.499]                       search = base::search(), system = base::Sys.info())
[01:28:35.499]                   }
[01:28:35.499]                   ...future.conditions[[length(...future.conditions) + 
[01:28:35.499]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:35.499]                     cond$call), session = sessionInformation(), 
[01:28:35.499]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:35.499]                   signalCondition(cond)
[01:28:35.499]                 }
[01:28:35.499]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:35.499]                 "immediateCondition"))) {
[01:28:35.499]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:35.499]                   ...future.conditions[[length(...future.conditions) + 
[01:28:35.499]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:35.499]                   if (TRUE && !signal) {
[01:28:35.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.499]                     {
[01:28:35.499]                       inherits <- base::inherits
[01:28:35.499]                       invokeRestart <- base::invokeRestart
[01:28:35.499]                       is.null <- base::is.null
[01:28:35.499]                       muffled <- FALSE
[01:28:35.499]                       if (inherits(cond, "message")) {
[01:28:35.499]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:35.499]                         if (muffled) 
[01:28:35.499]                           invokeRestart("muffleMessage")
[01:28:35.499]                       }
[01:28:35.499]                       else if (inherits(cond, "warning")) {
[01:28:35.499]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:35.499]                         if (muffled) 
[01:28:35.499]                           invokeRestart("muffleWarning")
[01:28:35.499]                       }
[01:28:35.499]                       else if (inherits(cond, "condition")) {
[01:28:35.499]                         if (!is.null(pattern)) {
[01:28:35.499]                           computeRestarts <- base::computeRestarts
[01:28:35.499]                           grepl <- base::grepl
[01:28:35.499]                           restarts <- computeRestarts(cond)
[01:28:35.499]                           for (restart in restarts) {
[01:28:35.499]                             name <- restart$name
[01:28:35.499]                             if (is.null(name)) 
[01:28:35.499]                               next
[01:28:35.499]                             if (!grepl(pattern, name)) 
[01:28:35.499]                               next
[01:28:35.499]                             invokeRestart(restart)
[01:28:35.499]                             muffled <- TRUE
[01:28:35.499]                             break
[01:28:35.499]                           }
[01:28:35.499]                         }
[01:28:35.499]                       }
[01:28:35.499]                       invisible(muffled)
[01:28:35.499]                     }
[01:28:35.499]                     muffleCondition(cond, pattern = "^muffle")
[01:28:35.499]                   }
[01:28:35.499]                 }
[01:28:35.499]                 else {
[01:28:35.499]                   if (TRUE) {
[01:28:35.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:35.499]                     {
[01:28:35.499]                       inherits <- base::inherits
[01:28:35.499]                       invokeRestart <- base::invokeRestart
[01:28:35.499]                       is.null <- base::is.null
[01:28:35.499]                       muffled <- FALSE
[01:28:35.499]                       if (inherits(cond, "message")) {
[01:28:35.499]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:35.499]                         if (muffled) 
[01:28:35.499]                           invokeRestart("muffleMessage")
[01:28:35.499]                       }
[01:28:35.499]                       else if (inherits(cond, "warning")) {
[01:28:35.499]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:35.499]                         if (muffled) 
[01:28:35.499]                           invokeRestart("muffleWarning")
[01:28:35.499]                       }
[01:28:35.499]                       else if (inherits(cond, "condition")) {
[01:28:35.499]                         if (!is.null(pattern)) {
[01:28:35.499]                           computeRestarts <- base::computeRestarts
[01:28:35.499]                           grepl <- base::grepl
[01:28:35.499]                           restarts <- computeRestarts(cond)
[01:28:35.499]                           for (restart in restarts) {
[01:28:35.499]                             name <- restart$name
[01:28:35.499]                             if (is.null(name)) 
[01:28:35.499]                               next
[01:28:35.499]                             if (!grepl(pattern, name)) 
[01:28:35.499]                               next
[01:28:35.499]                             invokeRestart(restart)
[01:28:35.499]                             muffled <- TRUE
[01:28:35.499]                             break
[01:28:35.499]                           }
[01:28:35.499]                         }
[01:28:35.499]                       }
[01:28:35.499]                       invisible(muffled)
[01:28:35.499]                     }
[01:28:35.499]                     muffleCondition(cond, pattern = "^muffle")
[01:28:35.499]                   }
[01:28:35.499]                 }
[01:28:35.499]             }
[01:28:35.499]         }))
[01:28:35.499]     }, error = function(ex) {
[01:28:35.499]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:35.499]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:35.499]                 ...future.rng), started = ...future.startTime, 
[01:28:35.499]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:35.499]             version = "1.8"), class = "FutureResult")
[01:28:35.499]     }, finally = {
[01:28:35.499]         if (!identical(...future.workdir, getwd())) 
[01:28:35.499]             setwd(...future.workdir)
[01:28:35.499]         {
[01:28:35.499]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:35.499]                 ...future.oldOptions$nwarnings <- NULL
[01:28:35.499]             }
[01:28:35.499]             base::options(...future.oldOptions)
[01:28:35.499]             if (.Platform$OS.type == "windows") {
[01:28:35.499]                 old_names <- names(...future.oldEnvVars)
[01:28:35.499]                 envs <- base::Sys.getenv()
[01:28:35.499]                 names <- names(envs)
[01:28:35.499]                 common <- intersect(names, old_names)
[01:28:35.499]                 added <- setdiff(names, old_names)
[01:28:35.499]                 removed <- setdiff(old_names, names)
[01:28:35.499]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:35.499]                   envs[common]]
[01:28:35.499]                 NAMES <- toupper(changed)
[01:28:35.499]                 args <- list()
[01:28:35.499]                 for (kk in seq_along(NAMES)) {
[01:28:35.499]                   name <- changed[[kk]]
[01:28:35.499]                   NAME <- NAMES[[kk]]
[01:28:35.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.499]                     next
[01:28:35.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:35.499]                 }
[01:28:35.499]                 NAMES <- toupper(added)
[01:28:35.499]                 for (kk in seq_along(NAMES)) {
[01:28:35.499]                   name <- added[[kk]]
[01:28:35.499]                   NAME <- NAMES[[kk]]
[01:28:35.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.499]                     next
[01:28:35.499]                   args[[name]] <- ""
[01:28:35.499]                 }
[01:28:35.499]                 NAMES <- toupper(removed)
[01:28:35.499]                 for (kk in seq_along(NAMES)) {
[01:28:35.499]                   name <- removed[[kk]]
[01:28:35.499]                   NAME <- NAMES[[kk]]
[01:28:35.499]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:35.499]                     next
[01:28:35.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:35.499]                 }
[01:28:35.499]                 if (length(args) > 0) 
[01:28:35.499]                   base::do.call(base::Sys.setenv, args = args)
[01:28:35.499]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:35.499]             }
[01:28:35.499]             else {
[01:28:35.499]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:35.499]             }
[01:28:35.499]             {
[01:28:35.499]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:35.499]                   0L) {
[01:28:35.499]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:35.499]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:35.499]                   base::options(opts)
[01:28:35.499]                 }
[01:28:35.499]                 {
[01:28:35.499]                   {
[01:28:35.499]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:35.499]                     NULL
[01:28:35.499]                   }
[01:28:35.499]                   options(future.plan = NULL)
[01:28:35.499]                   if (is.na(NA_character_)) 
[01:28:35.499]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:35.499]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:35.499]                   future::plan(list(a = function (..., workers = availableCores(), 
[01:28:35.499]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.499]                     envir = parent.frame()) 
[01:28:35.499]                   {
[01:28:35.499]                     if (is.function(workers)) 
[01:28:35.499]                       workers <- workers()
[01:28:35.499]                     workers <- structure(as.integer(workers), 
[01:28:35.499]                       class = class(workers))
[01:28:35.499]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.499]                       workers >= 1)
[01:28:35.499]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.499]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.499]                     }
[01:28:35.499]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.499]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.499]                       envir = envir)
[01:28:35.499]                     if (!future$lazy) 
[01:28:35.499]                       future <- run(future)
[01:28:35.499]                     invisible(future)
[01:28:35.499]                   }, b = function (..., workers = availableCores(), 
[01:28:35.499]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:35.499]                     envir = parent.frame()) 
[01:28:35.499]                   {
[01:28:35.499]                     if (is.function(workers)) 
[01:28:35.499]                       workers <- workers()
[01:28:35.499]                     workers <- structure(as.integer(workers), 
[01:28:35.499]                       class = class(workers))
[01:28:35.499]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:35.499]                       workers >= 1)
[01:28:35.499]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:35.499]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:35.499]                     }
[01:28:35.499]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:35.499]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:35.499]                       envir = envir)
[01:28:35.499]                     if (!future$lazy) 
[01:28:35.499]                       future <- run(future)
[01:28:35.499]                     invisible(future)
[01:28:35.499]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:35.499]                 }
[01:28:35.499]             }
[01:28:35.499]         }
[01:28:35.499]     })
[01:28:35.499]     if (TRUE) {
[01:28:35.499]         base::sink(type = "output", split = FALSE)
[01:28:35.499]         if (TRUE) {
[01:28:35.499]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:35.499]         }
[01:28:35.499]         else {
[01:28:35.499]             ...future.result["stdout"] <- base::list(NULL)
[01:28:35.499]         }
[01:28:35.499]         base::close(...future.stdout)
[01:28:35.499]         ...future.stdout <- NULL
[01:28:35.499]     }
[01:28:35.499]     ...future.result$conditions <- ...future.conditions
[01:28:35.499]     ...future.result$finished <- base::Sys.time()
[01:28:35.499]     ...future.result
[01:28:35.499] }
[01:28:35.505] Exporting 1 global objects (128 bytes) to cluster node #1 ...
[01:28:35.505] Exporting 'data' (128 bytes) to cluster node #1 ...
[01:28:35.506] Exporting 'data' (128 bytes) to cluster node #1 ... DONE
[01:28:35.506] Exporting 1 global objects (128 bytes) to cluster node #1 ... DONE
[01:28:35.507] MultisessionFuture started
[01:28:35.507] - Launch lazy future ... done
[01:28:35.507] run() for 'MultisessionFuture' ... done
[01:28:35.507] result() for ClusterFuture ...
[01:28:35.508] receiveMessageFromWorker() for ClusterFuture ...
[01:28:35.508] - Validating connection of MultisessionFuture
[01:28:35.550] - received message: FutureResult
[01:28:35.550] - Received FutureResult
[01:28:35.551] - Erased future from FutureRegistry
[01:28:35.551] result() for ClusterFuture ...
[01:28:35.551] - result already collected: FutureResult
[01:28:35.551] result() for ClusterFuture ... done
[01:28:35.551] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:35.551] result() for ClusterFuture ... done
[01:28:35.552] result() for ClusterFuture ...
[01:28:35.552] - result already collected: FutureResult
[01:28:35.552] result() for ClusterFuture ... done
- plan(list('multisession', 'multisession')) ... DONE
> 
> message("*** Nested futures ... DONE")
*** Nested futures ... DONE
> 
> source("incl/end.R")
[01:28:35.553] plan(): Setting new future strategy stack:
[01:28:35.553] List of future strategies:
[01:28:35.553] 1. FutureStrategy:
[01:28:35.553]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:35.553]    - tweaked: FALSE
[01:28:35.553]    - call: future::plan(oplan)
[01:28:35.554] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS43_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUBDIRS_STRICT_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_INSTALL_TIME_PATCHES_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.40    0.10    3.37